|
| 1 | +// Package trit implements three-valued logic operations with False, |
| 2 | +// Unknown, and True states. |
| 3 | +// |
| 4 | +// # Overview |
| 5 | +// |
| 6 | +// Trit (short for "trinary digit") is an information unit that can take three |
| 7 | +// states: False (-1), Unknown (0), and True (1). It serves as the fundamental |
| 8 | +// unit of trinary/ternary logic systems, with applications in: |
| 9 | +// - Database systems (SQL NULL handling) |
| 10 | +// - Logic circuits and digital design |
| 11 | +// - Decision systems with uncertainty |
| 12 | +// - Artificial intelligence and expert systems |
| 13 | +// - Configuration management |
| 14 | +// |
| 15 | +// Key Features |
| 16 | +// - Basic type conversion (from/to bool, int, float) |
| 17 | +// - Fundamental unary operations (NOT, MA, LA, IA) |
| 18 | +// - Binary logic operations (AND, OR, XOR, etc.) |
| 19 | +// - Extended operations (IMP, EQ, MIN, MAX) |
| 20 | +// - Thread-safe parallel operations for slices |
| 21 | +// - Full set of comparison and testing methods |
| 22 | +// |
| 23 | +// # Quick Start |
| 24 | +// |
| 25 | +// Basic usage example: |
| 26 | +// |
| 27 | +// t1 := trit.True |
| 28 | +// t2 := trit.Unknown |
| 29 | +// result := t1.And(t2) // Unknown |
| 30 | +// isTrue := result.IsTrue() // false |
| 31 | +// |
| 32 | +// # Type System |
| 33 | +// |
| 34 | +// The package implements type Trit as int8 with three main states: |
| 35 | +// - False: Any negative value (-1 and below) |
| 36 | +// - Unknown: Zero (0) |
| 37 | +// - True: Any positive value (1 and above) |
| 38 | +// |
| 39 | +// # Truth Tables |
| 40 | +// |
| 41 | +// The package implements the following truth tables for three-valued logic: |
| 42 | +// |
| 43 | +// 1. Unary Operations: |
| 44 | +// |
| 45 | +// - NA (Not): Logical negation |
| 46 | +// |
| 47 | +// - MA (Modus Ponens Absorption) |
| 48 | +// |
| 49 | +// - LA (Law of Absorption) |
| 50 | +// |
| 51 | +// - IA (Implication Absorption) |
| 52 | +// |
| 53 | +// A | NA A | MA A | LA A | IA |
| 54 | +// ----+---- ----+---- ----+---- ----+---- |
| 55 | +// F | T F | F F | F F | F |
| 56 | +// U | U U | T U | F U | T |
| 57 | +// T | F T | T T | T T | F |
| 58 | +// |
| 59 | +// 2. Basic Binary Operations: |
| 60 | +// |
| 61 | +// - AND: Logical conjunction |
| 62 | +// |
| 63 | +// - OR: Logical disjunction |
| 64 | +// |
| 65 | +// - XOR: Exclusive OR |
| 66 | +// |
| 67 | +// A | B | AND A | B | OR A | B | XOR |
| 68 | +// ---+---+------ ---+---+------ ---+---+------ |
| 69 | +// F | F | F F | F | F F | F | F |
| 70 | +// F | U | F F | U | U F | U | U |
| 71 | +// F | T | F F | T | T F | T | T |
| 72 | +// U | F | F U | F | U U | F | U |
| 73 | +// U | U | U U | U | U U | U | U |
| 74 | +// U | T | U U | T | T U | T | U |
| 75 | +// T | F | F T | F | T T | F | T |
| 76 | +// T | U | U T | U | T T | U | U |
| 77 | +// T | T | T T | T | T T | T | F |
| 78 | +// |
| 79 | +// 3. Negative Binary Operations: |
| 80 | +// |
| 81 | +// - NAND: Logical NAND (NOT AND) |
| 82 | +// |
| 83 | +// - NOR: Logical NOR (NOT OR) |
| 84 | +// |
| 85 | +// - NXOR: Logical XNOR (NOT XOR) |
| 86 | +// |
| 87 | +// A | B | NAND A | B | NOR A | B | NXOR |
| 88 | +// ---+---+------ ---+---+------ ---+---+------ |
| 89 | +// F | F | T F | F | T F | F | T |
| 90 | +// F | U | T F | U | U F | U | U |
| 91 | +// F | T | T F | T | F F | T | F |
| 92 | +// U | F | T U | F | U U | F | U |
| 93 | +// U | U | U U | U | U U | U | U |
| 94 | +// U | T | U U | T | F U | T | U |
| 95 | +// T | F | T T | F | F T | F | F |
| 96 | +// T | U | U T | U | F T | U | U |
| 97 | +// T | T | F T | T | F T | T | T |
| 98 | +// |
| 99 | +// 4. Extended Operations: |
| 100 | +// |
| 101 | +// - IMP: Implication (Lukasiewicz Logic) |
| 102 | +// |
| 103 | +// - EQ: Equivalence (If and only if) |
| 104 | +// |
| 105 | +// - MIN: Minimum value |
| 106 | +// |
| 107 | +// - NIMP: Inverse implication |
| 108 | +// |
| 109 | +// - NEQ: Non-equivalence |
| 110 | +// |
| 111 | +// - MAX: Maximum value |
| 112 | +// |
| 113 | +// A | B | IMP A | B | EQ A | B | MIN |
| 114 | +// ---+---+------ ---+---+------ ---+---+------ |
| 115 | +// F | F | T F | F | T F | F | F |
| 116 | +// F | U | T F | U | U F | U | F |
| 117 | +// F | T | T F | T | F F | T | F |
| 118 | +// U | F | U U | F | U U | F | F |
| 119 | +// U | U | T U | U | U U | U | U |
| 120 | +// U | T | T U | T | U U | T | U |
| 121 | +// T | F | F T | F | F T | F | F |
| 122 | +// T | U | U T | U | U T | U | U |
| 123 | +// T | T | T T | T | T T | T | T |
| 124 | +// |
| 125 | +// A | B | NIMP A | B | NEQ A | B | MAX |
| 126 | +// ---+---+------ ---+---+------ ---+---+------ |
| 127 | +// F | F | F F | F | F F | F | F |
| 128 | +// F | U | F F | U | U F | U | U |
| 129 | +// F | T | F F | T | T F | T | T |
| 130 | +// U | F | U U | F | U U | F | U |
| 131 | +// U | U | F U | U | U U | U | U |
| 132 | +// U | T | F U | T | U U | T | T |
| 133 | +// T | F | T T | F | T T | F | T |
| 134 | +// T | U | U T | U | U T | U | T |
| 135 | +// T | T | F T | T | F T | T | T |
| 136 | +// |
| 137 | +// # Thread Safety |
| 138 | +// |
| 139 | +// All operations in this package are thread-safe. The parallel operations |
| 140 | +// (All, Any, Known) use goroutines for processing large slices and include |
| 141 | +// proper synchronization mechanisms. |
| 142 | +// |
| 143 | +// # Performance Considerations |
| 144 | +// |
| 145 | +// The package optimizes performance by: |
| 146 | +// - Using int8 as the underlying type |
| 147 | +// - Implementing efficient parallel processing for slice operations |
| 148 | +// - Providing direct value access methods |
| 149 | +// - Minimizing memory allocations |
| 150 | +// |
| 151 | +// For more examples and detailed API documentation, see the individual method |
| 152 | +// documentation and the package examples. |
| 153 | +package trit |
0 commit comments