Ternary logic: Difference between revisions

Content added Content deleted

Inline

@@ Line 2,980: / 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 in trit) console.log(display.not + trit[a] + ' = ' + not(trit[a]))
+for (let a of trit_values) log += `${display.not}${a} = ${a}\n`
+log += '\nNAND         AND          OR           NOR          IMPLIES       IFF'
-for (let op in functor) {
+for (let a of trit_values) {
-    console.log('\n----> ' + op);
-    for (let a in trit) {
+    for (let b of trit_values) {
-        for (let b in trit)
+        log += "\n"
-            console.log('' + trit[a] + ' ' + display[op] + ' ' + trit[b] + ' = ' + functor[op](trit[a], trit[b]))
+        for (let op in functor) log += `${a} ${display[op]} ${b} = ${functor[op](a, b)}    `
     }
 }
+console.log(log)
 </lang>
 ...Output:
 <lang>
+NOT
-----> not
-¬F = T
+¬F = F
 ¬U = U
-¬T = F
+¬T = T
+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>