Ternary logic: Difference between revisions
Content added Content deleted
Thundergnat (talk | contribs) m (→{{header|Perl 6}}: Combine blocks to make runnable code for ease of automated testing) |
|||
Line 1,726: | Line 1,726: | ||
end program ternaryLogic |
end program ternaryLogic |
||
</lang> |
</lang> |
||
=={{header|Free Pascal}}== |
|||
Free Pascal version with lookup. |
|||
<lang pascal>program ternarytests; |
|||
{$mode objfpc} |
|||
type |
|||
{ ternary type } |
|||
trit = (F, U, T); |
|||
operator and (const a,b:trit):trit;inline; |
|||
const lookupAnd:array[trit,trit] of trit = |
|||
((F,F,F),(F,U,U),(F,U,T)); |
|||
begin |
|||
Result:= LookupAnd[a,b]; |
|||
end; |
|||
operator or (const a,b:trit):trit;inline; |
|||
const lookupOr:array[trit,trit] of trit = |
|||
((F,U,T),(U,U,T),(T,T,T)); |
|||
begin |
|||
Result := LookUpOr[a,b]; |
|||
end; |
|||
operator not (const a:trit):trit;inline; |
|||
const LookupNot:array[trit] of trit =(T,U,F); |
|||
begin |
|||
Result:= LookUpNot[a]; |
|||
end; |
|||
operator xor (const a,b:trit):trit;inline; |
|||
const LookupXor:array[trit,trit] of trit = |
|||
((F,U,T),(U,U,U),(T,U,F)); |
|||
begin |
|||
Result := LookupXor[a,b]; |
|||
end; |
|||
{ using one of the free set operators for EQU } |
|||
operator >< (const a,b:trit):trit;inline; |
|||
const LookupXor:array[trit,trit] of trit = |
|||
((T,U,F),(U,U,U),(F,U,T)); |
|||
begin |
|||
Result := LookupXor[a,b]; |
|||
end; |
|||
{ using the free power operator for IMP } |
|||
operator ** (const a,b:trit):trit;inline; |
|||
const LookupXor:array[trit,trit] of trit = |
|||
((T,T,T),(U,U,T),(F,U,T)); |
|||
begin |
|||
Result := LookupXor[a,b]; |
|||
end; |
|||
{ or if you don't like the two above, use functions } |
|||
function EQU(const a,b:trit):trit;inline; |
|||
begin |
|||
Result := NOT (a XOR b) ; |
|||
end; |
|||
function IMP(const a,b:trit):trit;inline; |
|||
begin |
|||
Result := NOT(a) OR b; |
|||
end; |
|||
begin |
|||
writeln(' a AND b'); |
|||
writeln('__FUT'); |
|||
writeln('F|',F and F,F and U,F and T); |
|||
writeln('U|',U and F,U and U,U and T); |
|||
writeln('T|',T and F,T and U,T and T); |
|||
writeln; |
|||
writeln(' a OR b'); |
|||
writeln('__FUT'); |
|||
writeln('F|',F or F,F or U,F or T); |
|||
writeln('U|',U or F,U or U,U or T); |
|||
writeln('T|',T or F,T or U,T or T); |
|||
writeln; |
|||
writeln(' NOT a'); |
|||
writeln('__FUT'); |
|||
writeln('F|',not F); |
|||
writeln('U|',not U); |
|||
writeln('T|',not T); |
|||
writeln; |
|||
writeln(' a XOR b'); |
|||
writeln('__FUT'); |
|||
writeln('F|',F xor F,F xor U,F xor T); |
|||
writeln('U|',U xor F,U xor U,U xor T); |
|||
writeln('T|',T xor F,T xor U,T xor T); |
|||
writeln; |
|||
writeln(' NOT (a XOR b) -> equivalent'); |
|||
writeln('__FUT'); |
|||
writeln('F|',not(F xor F),not(F xor U),not(F xor T)); |
|||
writeln('U|',not(U xor F),not(U xor U),not(U xor T)); |
|||
writeln('T|',not(T xor F),not(T xor U),not(T xor T)); |
|||
writeln; |
|||
writeln(' using >< as EQU -> equivalence'); |
|||
writeln('__FUT'); |
|||
writeln('F|',F >< F,F >< U,F >< T); |
|||
writeln('U|',U >< F,U >< U,U >< T); |
|||
writeln('T|',T >< F,T >< U,T >< T); |
|||
writeln; |
|||
writeln(' NOT(a) OR b -> IMP. a.k.a. IfThen'); |
|||
writeln('T|',(not T) or T,(not T) or U,(not T) or F); |
|||
writeln('U|',(not U) or T,(not U) or U,(not U) or F); |
|||
writeln('F|',(not F) or T,(not F) or U,(not F) or F); |
|||
writeln; |
|||
writeln(' using ** as IMP a.k.a. IfThen'); |
|||
writeln('T|',T ** T,T ** U,T ** F); |
|||
writeln('U|',U ** T,U ** U,U ** F); |
|||
writeln('F|',F ** T,F ** U,F ** F); |
|||
end.</lang> |
|||
<pre> |
|||
Output: |
|||
a AND b |
|||
__FUT |
|||
F|FFF |
|||
U|FUU |
|||
T|FUT |
|||
a OR b |
|||
__FUT |
|||
F|FUT |
|||
U|UUT |
|||
T|TTT |
|||
NOT a |
|||
__FUT |
|||
F|T |
|||
U|U |
|||
T|F |
|||
a XOR b |
|||
__FUT |
|||
F|FUT |
|||
U|UUU |
|||
T|TUF |
|||
NOT (a XOR b) -> equivalent |
|||
__FUT |
|||
F|TUF |
|||
U|UUU |
|||
T|FUT |
|||
using >< as EQU -> equivalence |
|||
__FUT |
|||
F|TUF |
|||
U|UUU |
|||
T|FUT |
|||
NOT(a) OR b -> IMP. a.k.a. IfThen |
|||
T|TUF |
|||
U|TUU |
|||
F|TTT |
|||
using ** as IMP a.k.a. IfThen |
|||
T|TUF |
|||
U|TUU |
|||
F|TTT</pre> |
|||
=={{header|Go}}== |
=={{header|Go}}== |