Ternary logic: Difference between revisions

{|

|+'''Example ''Ternary Logic Operators'' in ''Truth Tables'':'''

|}

|}

* Define a new type that emulates ''ternary logic'' by storing data '''trits'''.

* Given all the binary logic operators of the original programming language, reimplement these operators for the new ''Ternary logic'' type '''trit'''.

* Generate a sampling of results using '''trit''' variables.

* [[wp:Kudos|Kudos]] for actually thinking up a test case algorithm where ''ternary logic'' is intrinsically useful, optimises the test case algorithm and is preferable to binary logic.

 

=={{header|Ada}}==

 

We first specify a package "Logic" for three-valued logic. Observe that predefined Boolean functions, "and" "or" and "not" are overloaded:

type Ternary is (True, Unknown, False);

 

function To_Ternary(B: Boolean) return Ternary;

function Image(Value: Ternary) return Character;

 

Next, the implementation of the package:

 

-- type Ternary is (True, Unknown, False);

 

end Implies;

 

 

Finally, a sample program:

 

procedure Test_Tri_Logic is

Truth_Table(F => Equivalent'Access, Name => "Eq");

Truth_Table(F => Implies'Access, Name => "Implies");

 

T | F

? | ?

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

'''File: Ternary_logic.a68'''

 

INT trit width = 1, trit base = 3;

#true # (false, maybe, true )

)[@-1,@-1][INITINT a, INITINT b]

 

OP & = (LOGICAL a,b)LOGICAL: a AND b;

OP ~ = (LOGICAL a)LOGICAL: NOT a,

~= = (LOGICAL a,b)LOGICAL: a /= b; SCALAR!

# -*- coding: utf-8 -*- #

 

print trit op table("⊃","IMPLIES", (TRIT a,b)TRIT: a IMPLIES b);

print trit op table("∧","AND", (TRIT a,b)TRIT: a AND b);

<pre>

Comparitive table of coercions:

---+---+---+---

⌈ | ⌈ | ⌈ | ⌈

</pre>

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

REM Create a ternary class:

PRINT "TRUE EQV TRUE = " FN(mytrit.teqv)("TRUE","TRUE")

<pre>

Testing NOT:

MAYBE EQV TRUE = MAYBE

TRUE EQV TRUE = TRUE

</pre>

 

=={{header|C}}==

===Implementing logic using lookup tables===

typedef enum {

return 0;

 

Not ?: ?

Not F: T

F Equiv T: F

F Equiv ?: ?

 

===Using functions===

 

typedef enum { t_F = -1, t_M, t_T } trit;

 

return 0;

F | T

? | ?

F | T T T

? | ? ? T

 

===Variable truthfulness===

#include <stdlib.h>

 

 

return 0;

 

=={{header|C sharp|C#}}==

 

/// <summary>

}

}

<pre>¬True = False

True & True = True

False → False = True

False ≡ False = True</pre>

 

=={{header|Common Lisp}}==

(defun tri-and (&rest x) (apply #'* x))

(defun tri-or (&rest x) (tri-not (apply #'* (mapcar #'tri-not x))))

(print-table #'tri-or "OR")

(print-table #'tri-imply "IMPLY")

T | F

? | ?

T | T ? F

? | ? ? ?

 

=={{header|D}}==

Partial translation of a C entry:

 

struct Trit {

showOperation!"=="("Equiv");

showOperation!"==>"("Imply");

{{out}}

<pre>[Not]

 

=={{header|Delphi}}==

 

interface

end;

 

 

And that's the reason why you never on no account ''ever'' should compare against the values of True or False unless you intent ternary logic!

 

An alternative version would be using an enum type

and defining a set of constants implementing the above tables:

tvl_not: array[TriBool] = (tbTrue, tbMaybe, tbFalse);

tvl_and: array[TriBool, TriBool] = (

(tbFalse, tbMaybe, tbTrue),

);

 

That's no real fun, but lookup can then be done with

 

=={{header|Factor}}==

For boolean logic, Factor uses ''t'' and ''f'' with the words ''>boolean'', ''not'', ''and'', ''or'', ''xor''. For ternary logic, we add ''m'' and define the words ''>trit'', ''tnot'', ''tand'', ''tor'', ''txor'' and ''t=''. Our new class, ''trit'', is the union class of ''t'', ''m'' and ''f''.

 

! http://rosettacode.org/wiki/Ternary_logic

USING: combinators kernel ;

{ m [ >trit drop m ] }

{ f [ tnot ] }

 

Example use:

( scratchpad ) trits [ tnot ] map .

{ f m t }

{ { f m t } { m m m } { t m f } }

( scratchpad ) trits [ trits swap [ t= ] curry map ] map .

 

=={{header|Go}}==

Go has four operators for the bool type: ==, &&, ||, and !.

 

import "fmt"

 

const (

trMaybe

trTrue

}

}

<pre>

t not t

=={{header|Groovy}}==

Solution:

TRUE, MAYBE, FALSE

Trit imply(Trit that) { this.nand(that.not()) }

Trit equiv(Trit that) { this.and(that).or(this.nor(that)) }

 

Test:

Trit.values().each { b -> printf ('%6s', b) }

println '\n ----- ----- -----'

Trit.values().each { b -> printf ('%6s', a.equiv(b)) }

println()

 

<pre>AND

TRUE MAYBE FALSE

All operations given in terms of NAND, the functionally-complete operation.

 

 

main = mapM_ (putStrLn . unlines . map unwords)

where header = map (:[]) (take ((length $ head xs) - 1) ['A'..]) ++ [name]

 

 

<pre>A not

True False

 

=={{header|Icon}} and {{header|Unicon}}==

* Strictly speaking there are no binary values in Icon and Unicon. There are a number of flow control operations that result in expression success (and a result) or failure which affects flow. As a result there really isn't a set of binary operators to map into ternary. The example provides the minimum required by the task plus xor.

* The code below does not define a data type as it doesn't really make sense in this case. Icon and Unicon can create records which would be overkill and clumsy in this case. Unicon can create objects which would also be overkill. The only remaining option is to reinterpret one of the existing types as ternary values. The code below implements balanced ternary values as integers in order to simplify several of the functions.

 

 

$define FALSE -1

$define UNKNOWN 0

procedure xor3(a,b) #: xor of two trits or error if invalid

return not3(eq3(a,b))

 

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/procs/printf.icn printf.icn provides support for the printf family of functions]

 

T : F

F : T

maybe: 0.5

 

and=: <.

or =: >.

if =: (>. -.)"0~

 

Example use:

 

1 0.5 0

 

1 0.5 0

0.5 0.5 0.5

 

Note that this implementation is a special case of "[[wp:fuzzy logic|fuzzy logic]]" (using a limited set of values).

 

 

Note that we might instead define values between 0 and 1 to represent independent probabilities:

 

and=: *

or=: *&.-.

if =: (or -.)"0~

 

 

1 0.5 0

 

1 0.5 0

0.5 0.4375 0.5

 

Another interesting possibility would involve using George Boole's original operations. This leaves us without any "not", (if we include the definition of logical negation which was later added to the definition of Boolean algebra, then the only numbers which can be used with Boolean algebra are 1 and 0). So, it's not clear how we would implement "if" or "eq". However, "and" and "or" would look like this:

 

 

And, the boolean result tables would look like this:

 

0 0 0

0 0.5 1

0 0.5 1

0.5 0.5 0.5

 

=={{header|Java}}==

{{works with|Java|1.5+}}

public static enum Trit{

TRUE, MAYBE, FALSE;

}

}

<pre>not TRUE: FALSE

not MAYBE: MAYBE

FALSE and MAYBE: FALSE FALSE or MAYBE: MAYBE FALSE implies MAYBE: TRUE FALSE = MAYBE: MAYBE

FALSE and FALSE: FALSE FALSE or FALSE: FALSE FALSE implies FALSE: TRUE FALSE = FALSE: TRUE</pre>

 

=={{header|Liberty BASIC}}==

'ternary logic

'0 1 2

longName3$ = word$("False,Don't know,True", i+1, ",")

end function

 

<pre>

Short and long names for ternary logic values

</pre>

 

Type definition is not allowed in Mathematica. We can just use the build-in symbols "True" and "False", and add a new symbol "Maybe".

Example:

Print@Grid[

ArrayFlatten[{{{{Not}}, {{Null}}}, {List /@ trits,

Null}}}, {{{Null}}, {trits}}, {List /@ trits,

Outer[operator, trits, trits]}}]], {operator, {And, Or, Nand,

<pre>Not

True False

Maybe Maybe

False True

 

And

Maybe Maybe Maybe False

False False False False

 

 

Maybe True Maybe Maybe

False True Maybe False

 

 

Maybe Maybe Maybe True

False True True True

 

 

Maybe False Maybe Maybe

False False Maybe True

 

 

Maybe Maybe Maybe Maybe

False True Maybe False

 

 

Maybe True Maybe Maybe

False True True True

 

 

True True Maybe False

Maybe Maybe Maybe Maybe

 

=={{header|МК-61/52}}==

+ 3 x^y ИП0 <-> / [x] ^ ^ 3

/ [x] 3 * - 1 - С/П 1 5

6 3 3 БП 00 1 9 5 6 9

БП 00 1 5 9 2 9 БП 00 1

 

<u>Instruction</u>:

 

''a'', ''b'' ∈ {-1, 0, 1}.

 

=={{header|OCaml}}==

 

 

let t_not = function

print t_imply "Then";

print t_eq "Equiv";

 

<pre>

Not True: False

=== Using a general binary -> ternary transform ===

Instead of writing all of the truth-tables by hand, we can construct a general binary -> ternary transform and apply it to any logical function we want:

 

let to_bin = function True -> [true] | False -> [false] | Maybe -> [true;false]

table2 "or" t_or;;

table2 "equiv" t_equiv;;

<pre>

not:

 

=={{header|ooRexx}}==

tritValues = .array~of(.trit~true, .trit~false, .trit~maybe)

tab = '09'x

else if self == .trit~maybe then return .trit~maybe

else return \other

 

<pre>

 

=={{header|Pascal}}==

 

type

writeln('False ', terToStr(terEquals(terTrue,terFalse)), ' ', terToStr(terEquals(terMayBe,terFalse)), ' ', terToStr(terEquals(terFalse,terFalse)));

writeln;

<pre>

:> ./TernaryLogic

 

=={{header|Perl}}==

 

 

 

 

use overload

;

 

}

 

}

 

 

 

 

 

 

 

 

 

 

true false

maybe maybe

maybe 1

false 1</pre>

 

 

 

 

 

}

 

 

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

In addition for the standard T (for "true") and NIL (for "false") we define 0 (zero, for "maybe").

(or (=0 A) (not A)) )

 

((=T A) B)

((=0 A) 0)

Test:

(println 'not X '-> (3not X)) )

 

(for X '(T 0 NIL)

(for Y '(T 0 NIL)

not 0 -> 0

not NIL -> T

NIL equivalent 0 -> 0

NIL equivalent NIL -> T</pre>

 

=={{header|Python}}==

In Python, the keywords 'and', 'not', and 'or' are coerced to always work as boolean operators. I have therefore overloaded the boolean bitwise operators &, |, ^ to provide the required functionality.

def __new__(cls, value):

if value == 'TRUE':

for b in values:

expr = '%s %s %s' % (a, op, b)

 

<pre>

Trit logical inverse, '~'

>>> </pre>

 

=={{header|Racket}}==

 

(define-type trit (U 'true 'false 'maybe))

 

(for*: : Void ([a (in-list '(true maybe false))]

[b (in-list '(true maybe false))])

 

<pre>not true = false

not maybe = maybe

</pre>