Ternary logic: Difference between revisions

=={{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>