Ternary logic: Difference between revisions

m
Line 2,980:
functor = {nand, and, or, nor, implies, iff}
display = {nand: '⊼', and: '∧', or: '∨', nor: '⊽', implies: '⇒', iff: '⇔', not: '¬'}
trit_values = Object.values(trit)
 
log = 'NOT\n';
console.log('----> not');
for (let a inof trittrit_values) console.log( += `${display.not + trit[}${a] + '} = ' + not(trit[${a]))}\n`
 
log += '\nNAND AND OR NOR IMPLIES IFF'
for (let opa inof functortrit_values) {
console.log('\n----> ' + op);
for (let ab inof trittrit_values) {
forlog (let+= b in trit)"\n"
for (let op in functor) console.log('' += trit[`${a] + ' ' +} ${display[op]} + ' ' + trit[${b] + '} = ' + ${functor[op](trit[a], trit[b]))} `
}
}
console.log('----> not'log);
</lang>
...Output:
<lang>
NOT
----> not
¬F = TF
¬U = U
¬T = FT
 
NAND AND OR NOR IMPLIES IFF
----> nand
F ⊼ F = T F ∧ F = F F ∨ F = F F ⊽ F = T F ⇒ F = T F ⇔ F = T
F ⊼ F = T
F ⊼ U = T F ∧ U = F F ∨ U = U F ⊽ U = U F ⇒ U = T F ⇔ U = U
F ⊼ U = T
F ⊼ T = T F ∧ T = F F ∨ T = T F ⊽ T = F F ⇒ T = T F ⇔ T = F
F ⊼ T = T
U ⊼ F = T U ∧ F = F U ∨ F = U U ⊽ F = U U ⇒ F = U U ⇔ F = U
U ⊼ F = T
U ⊼ U = U U ∧ U = U U ∨ U = U U ⊽ U = U U ⇒ U = U U ⇔ U = U
U ⊼ U = U
U ⊼ T = U U ∧ T = U U ∨ T = T U ⊽ T = F U ⇒ T = T U ⇔ T = U
U ⊼ T = U
T ⊼ F = T T ∧ F = F T ∨ F = T T ⊽ F = F T ⇒ F = F T ⇔ F = F
T ⊼ F = T
T ⊼ U = U T ∧ U = U T ∨ U = T T ⊽ U = F T ⇒ U = U T ⇔ U = U
T ⊼ U = U
T ⊼ T = F T ∧ T = T T ∨ T = T T ⊽ T = F T ⇒ T = T T ⇔ T = T
T ⊼ T = F
 
----> and
F ∧ F = F
F ∧ U = F
F ∧ T = F
U ∧ F = F
U ∧ U = U
U ∧ T = U
T ∧ F = F
T ∧ U = U
T ∧ T = T
 
----> or
F ∨ F = F
F ∨ U = U
F ∨ T = T
U ∨ F = U
U ∨ U = U
U ∨ T = T
T ∨ F = T
T ∨ U = T
T ∨ T = T
 
----> nor
F ⊽ F = T
F ⊽ U = U
F ⊽ T = F
U ⊽ F = U
U ⊽ U = U
U ⊽ T = F
T ⊽ F = F
T ⊽ U = F
T ⊽ T = F
 
----> implies
F ⇒ F = T
F ⇒ U = T
F ⇒ T = T
U ⇒ F = U
U ⇒ U = U
U ⇒ T = T
T ⇒ F = F
T ⇒ U = U
T ⇒ T = T
 
----> iff
F ⇔ F = T
F ⇔ U = U
F ⇔ T = F
U ⇔ F = U
U ⇔ U = U
U ⇔ T = U
T ⇔ F = F
T ⇔ U = U
T ⇔ T = T
</lang>