Ternary logic: Difference between revisions

Note:   '''[[wp:Setun|Setun]]'''   (Сетунь) was a   [[wp:balanced ternary|balanced ternary]]   computer developed in 1958 at   [[wp:Moscow State University|Moscow State University]].   The device was built under the lead of   [[wp:Sergei Sobolev|Sergei Sobolev]]   and   [[wp:Nikolay Brusentsov|Nikolay Brusentsov]].   It was the only modern   [[wp:ternary computer|ternary computer]],   using three-valued [[wp:ternary logic|ternary logic]]

<br><br>

 

=={{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");

 

{{out}}

{{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);

{{out}}

<pre>

⌈ | ⌈ | ⌈ | ⌈

</pre>

 

=={{header|AutoHotkey}}==

SetFormat, Float, 2.1

return Abs(a-1)

Ternary_Equiv(a,b){

return a=b?1:a=1?b:b=1?a:0.5

bb:=[1,0.5,0]

 

StringReplace, Res, Res, 0, false, all

MsgBox % Res

{{out}}

<pre> Ternary_Not true = false

false Ternary_equiv false = true</pre>

 

 

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

{{works with|BBC BASIC for Windows}}

REM Create a ternary class:

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

{{out}}

<pre>

MAYBE EQV TRUE = MAYBE

TRUE EQV TRUE = TRUE

</pre>

 

=={{header|C}}==

===Implementing logic using lookup tables===

typedef enum {

return 0;

 

{{out}}

 

===Using functions===

 

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

 

return 0;

{{out}}

<pre>[Not]

the result is randomly sampled to true or false according to the chance.

(This description is definitely very confusing perhaps).

#include <stdlib.h>

 

 

return 0;

 

=={{header|C++}}==

Essentially the same logic as the [[#Using functions|Using functions]] implementation above, but using class-based encapsulation and overridden operators.

#include <stdlib.h>

 

show_op(==);

return EXIT_SUCCESS;

{{out}}

<pre>! ----

? | ? ? ?

F | F ? T</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")

{{out}}

<pre>NOT:

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

 

sealed class Trit

{

 

 

}

{{out}}

<pre>

 

=={{header|Erlang}}==

-module(ternary).

-export([main/0, nott/1, andd/2,orr/2, then/2, equiv/2]).

io: format("~s\n", [B])

end.

 

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

 

Please find the demonstration and compilation with gfortran at the start of the code. A module contains the ternary logic for easy reuse. Consider input redirection from unixdict.txt as vestigial. Or I could delete it.

!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Mon May 20 23:05:46

 

end program ternaryLogic

 

=={{header|Free Pascal}}==

Free Pascal version with lookup.

type

operator and (const a,b:trit):trit;inline;

begin

Result:= LookupAnd[a,b];

operator or (const a,b:trit):trit;inline;

begin

Result := LookUpOr[a,b];

operator not (const a:trit):trit;inline;

begin

Result:= LookUpNot[a];

end;

begin

Result := LookupXor[a,b];

end;

 

begin

end;

begin

end;

begin

writeln(' a AND b');

writeln;

writeln(' a OR b');

writeln;

writeln(' NOT a');

writeln;

writeln(' a XOR b');

writeln;

writeln;

<pre>

Output:

 

a OR b

 

NOT a

 

a XOR b

 

 

 

 

 

 

=={{header|Go}}==

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

 

import "fmt"

}

}

{{out}}

<pre>

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

 

{{out}}

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]

 

 

{{out}}

 

 

$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}}

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~

 

However, while this might be a more intellectually satisfying approach, this gives us some different results from the task requirement, for the combination of two "maybe" values (we could "fix" this by adding some "logic" which replaced any non-integer value with "0.5" - this would satisfy literal compliance with the task specification and might even be a valid engineering choice if we are implementing in hardware, for example):

 

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;

}

}

{{out}}

<pre>not TRUE: FALSE

Let's use the trit already available in JavaScript:

true, false (both boolean) and undefined…

 

L3.not = function(a) {

return L3.and(L3.ifThen(a, b), L3.ifThen(b, a));

}

… and try these:

L3.not(true) // false

L3.not(var a) // undefined

 

L3.iff(a, 2 == 2) // undefined

 

=={{header|jq}}==

as the three values since ternary logic agrees with Boolean logic for true and false, and because jq prints these three values consistently.

 

if a == false or b == false then true

elif a == "maybe" or b == "maybe" then "maybe"

display_equiv( (false, "maybe", true ); (false, "maybe", true) ),

"etc etc"

{{out}}

<pre>"false and false is false"

{{works with|Julia|0.6}}

 

const trits = (False, Maybe, True)

 

for a in trits

println(join(@sprintf("%10s ≡ %5s is %5s", a, b, a ≡ b) for b in trits))

 

{{out}}

Maybe ≡ False is Maybe Maybe ≡ Maybe is Maybe Maybe ≡ True is Maybe

True ≡ False is False True ≡ Maybe is Maybe True ≡ True is True</pre>

 

=={{header|Kotlin}}==

 

enum class Trit {

println()

}

 

{{out}}

F | F M T

</pre>

 

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

'ternary logic

'0 1 2

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

end function

 

{{out}}

T ? ? T ? ?

T T T T T F

</pre>

 

The following script generates all truth tables for Maple logical operations. Note that in addition to the usual built-in logical operators for '''not''', '''or''', '''and''', and '''xor''', Maple also has '''implies'''.

 

NotTable := Array(1..3, i->not tv[i] );

AndTable := Array(1..3, 1..3, (i,j)->tv[i] and tv[j] );

OrTable := Array(1..3, 1..3, (i,j)->tv[i] or tv[j] );

XorTable := Array(1..3, 1..3, (i,j)->tv[i] xor tv[j] );

 

{{Out}}

 

tv := [true, false, FAIL]

 

ImpliesTable := [true true true]

[ ]

 

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,

{{out}}

<pre>Not

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>:

 

=={{header|Nim}}==

 

proc `$`*(a: Trit): string =

t[a][b]

 

 

 

 

{{out}}

<pre>Not T: F

=={{header|OCaml}}==

 

 

let t_not = function

print t_imply "Then";

print t_eq "Equiv";

 

{{out}}

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

{{out}}

<pre>

 

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

{{out}}

<pre>

 

=={{header|Perl}}==

 

 

 

 

use overload

;

 

}

 

}

 

 

 

 

 

 

 

 

 

 

true false

maybe maybe

maybe 1

false 1</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|PHP}}==

Save the sample code as executable shell script on your *nix system:

<?php

 

}

 

Sample output:

<pre>--- Sample output for a equivalent b ---

for a=false and b=false a equivalent b is true

</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)

{{out}}

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)

 

{{out}}

>>> </pre>

 

=={{header|Racket}}==

 

; to avoid the hassle of adding a maybe value that is as special as

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

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

 

{{out}}

false iff maybe = maybe

false iff false = true

</pre>

 

=={{header|REXX}}==

This REXX program is a re-worked version of the REXX program used for the Rosetta Code task: &nbsp; ''truth table''.

/*──── and one or more expressions. */

/*──── Infix notation is supported with one character propositional constants. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

scan: procedure; parse arg x,at; L=length(x); t=L; lp=0; apost=0; quote=0

 

do j=abs(at) to t by sign(at); _=substr(x,j,1); __=substr(x,j,2)

apost=0; iterate

end

if _==' ' then iterate

if datatype(_,'U') then return j - (at<0)

if at<0 then return j + 1

return min(j,L)

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

<br><br>

maybe maybe ────► maybe

</pre>

 

=={{header|Ruby}}==

 

{{works with|Ruby|1.9}}

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

 

# false.trit == obj # => false, maybe or true

def trit; TritMagic; end

 

This IRB session shows ternary not, and, or, equal.

 

irb(main):001:0> require './trit'

=> true

=> false

irb(main):008:0> false.trit == maybe

 

This program shows all 9 outcomes from <code>a.trit ^ b</code>.

 

maybe = MAYBE

 

printf "%5s ^ %5s => %5s\n", a, b, a.trit ^ b

end

 

<pre>$ ruby -I. trit-xor.rb

 

=={{header|Run BASIC}}==

testDoNotKnow = 1 ' ?

testTrue = 2 ' T

function longName3$(i)

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

F False

? Don't know

<table border=1><TR align=center bgcolor=wheat><TD>x</td><td>y</td><td>x AND y</td><td>x OR y</td><td>x EQ y</td><td>x XOR y</td></tr><TR align=center><td>F</td><td>F</td><td>F</td><td>F</td><td>T</td><td>F</td></tr><TR align=center><td>F</td><td>?</td><td>F</td><td>?</td><td>F</td><td>T</td></tr><TR align=center><td>F</td><td>T</td><td>F</td><td>T</td><td>F</td><td>T</td></tr><TR align=center><td>?</td><td>F</td><td>F</td><td>?</td><td>F</td><td>T</td></tr><TR align=center><td>?</td><td>?</td><td>?</td><td>?</td><td>T</td><td>F</td></tr><TR align=center><td>?</td><td>T</td><td>?</td><td>T</td><td>F</td><td>T</td></tr><TR align=center><td>T</td><td>F</td><td>F</td><td>T</td><td>F</td><td>T</td></tr><TR align=center><td>T</td><td>?</td><td>?</td><td>T</td><td>F</td><td>T</td></tr><TR align=center><td>T</td><td>T</td><td>T</td><td>T</td><td>T</td><td>F</td></tr></table>

 

def nand(that:Trit):Trit=(this,that) match {

case (TFalse, _) => TTrue

println("\n- Equiv -")

for(a<-v; b<-v) println("%6s : %6s => %6s".format(a, b, a equiv b))

{{out}}

<pre>- NOT -

which use also short circuit evaluation.

 

 

const type: trit is new enum

end func;

 

const func trit: (in trit: aTrit1) xor (in trit: aTrit2) is

return tritImplies[succ(ord(aTrit1))][succ(ord(aTrit2))];

return tritImplies[succ(ord(aTrit1))][succ(ord(aTrit2))];

 

const func trit: (in trit: aTrit1) == (in trit: aTrit2) is

return tritEquiv[succ(ord(aTrit1))][succ(ord(aTrit2))];

 

# Begin of test code

writeTable(operand1 -> operand2, "->");

writeTable(operand1 == operand2, "==");

 

{{out}}

True | False Maybe True

</pre>

 

=={{header|Tcl}}==

The simplest way of doing this is by constructing the operations as truth tables. The code below uses an abbreviated form of truth table.

namespace eval ternary {

# Code generator

* false

}

Demonstrating:

puts "x /\\ y == x \\/ y"

puts " x | y || result"

puts [format " %-5s | %-5s || %-5s" $x $y $z]

}

{{out}}

<pre>

false | maybe || maybe

false | false || true

</pre>