Ternary logic: Difference between revisions

Content added Content deleted
(Switch from custom values to Javascript native values (false, undefined, true) which leads to a more usable library. Fix an error with the test output for the NOT function.)
Line 3,095: Line 3,095:
L3.iff(a, 2 == 2) // undefined
L3.iff(a, 2 == 2) // undefined
</syntaxhighlight>
</syntaxhighlight>
Here is a compact solution
Here is a compact, highly readable solution that uses undefined for the third value of the trit
<syntaxhighlight lang="javascript">
<syntaxhighlight lang="javascript">
⚫
nand = (a, b) => (a == false || b == false) ? true : (a == undefined || b == undefined) ? undefined : false
⚫
trit = {false: 'F', maybe: 'U', true: 'T'}
⚫
nand = (a, b) => (a == trit.false || b == trit.false) ? trit.true : (a == trit.maybe || b == trit.maybe) ? trit.maybe : trit.false
not = (a) => nand(a, a)
not = (a) => nand(a, a)
same = (a, b) => (a == undefined || b == undefined) ? undefined : a === b
and = (a, b) => not(nand(a, b))
and = (a, b) => not(nand(a, b))
or = (a, b) => nand(not(a), not(b))
or = (a, b) => nand(not(a), not(b))
Line 3,109: Line 3,109:
... to test it
... to test it
<syntaxhighlight lang="javascript">
<syntaxhighlight lang="javascript">
⚫
trit = [false, undefined, true]
functor = {nand, and, or, nor, implies, iff, xor}
display = {nand: '⊼', and: '∧', or: '∨', nor: '⊽', implies: '⇒', iff: '⇔', xor: '⊻', not: '¬'}
functor = {same, nand, and, or, nor, implies, iff, xor}
display = {same: '≡', nand: '⊼', and: '∧', or: '∨', nor: '⊽', implies: '⇒', iff: '⇔', xor: '⊻', not: '¬', false: 'F', undefined: 'U', true: 'T'}
values = Object.values(trit)


log = 'NOT\n';
log = 'NOT\n';
for (let a of values) log += `${display.not}${a} = ${a}\n`
for (let a of trit) log += `${display.not}${display[a]} = ${display[not(a)]}\n`


log += '\nNAND AND OR NOR IMPLIES IFF XOR'
log += '\nSAME NAND AND OR NOR IMPLIES IFF XOR'
for (let a of values) {
for (let a of trit) {
for (let b of values) {
for (let b of trit) {
log += "\n"
log += "\n"
for (let op in functor) log += `${a} ${display[op]} ${b} = ${functor[op](a, b)} `
for (let op in functor) log += `${display[a]} ${display[op]} ${display[b]} = ${display[functor[op](a, b)]} `
}
}
}
}
Line 3,128: Line 3,128:
<syntaxhighlight lang="text">
<syntaxhighlight lang="text">
NOT
NOT
¬F = F
¬F = T
¬U = U
¬U = U
¬T = T
¬T = F


NAND AND OR NOR IMPLIES IFF XOR
SAME NAND AND OR NOR IMPLIES IFF XOR
F ⊼ F = T F ∧ F = F F ∨ F = F F ⊽ F = T F ⇒ F = T F ⇔ F = T F ⊻ F = F
F ≡ F = T F ⊼ F = T F ∧ F = F F ∨ F = F F ⊽ F = T F ⇒ F = T F ⇔ F = T F ⊻ F = F
F ⊼ U = T F ∧ U = F F ∨ U = U F ⊽ U = U F ⇒ U = T F ⇔ U = U F ⊻ U = U
F ≡ U = U F ⊼ U = T F ∧ U = F F ∨ U = U F ⊽ U = U F ⇒ U = T F ⇔ U = U F ⊻ U = U
F ⊼ T = T F ∧ T = F F ∨ T = T F ⊽ T = F F ⇒ T = T F ⇔ T = F F ⊻ T = T
F ≡ T = F 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 = U
U ≡ F = U U ⊼ F = T U ∧ F = F U ∨ F = U U ⊽ F = U U ⇒ F = U U ⇔ F = U U ⊻ F = U
U ⊼ U = U U ∧ U = U U ∨ U = U U ⊽ U = U U ⇒ U = U U ⇔ U = U U ⊻ U = U
U ≡ U = U 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
U ≡ T = 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 ≡ F = F 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 ≡ U = U 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
T ≡ T = T T ⊼ T = F T ∧ T = T T ∨ T = T T ⊽ T = F T ⇒ T = T T ⇔ T = T T ⊻ T = F
</syntaxhighlight>
</syntaxhighlight>


Retrieved from "https://rosettacode.org/wiki/Ternary_logic"