Ternary logic: Difference between revisions

 

=={{header|Action!}}==

DEFINE FALSE="0"

DEFINE MAYBE="1"

OD

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Ternary_logic.png Screenshot from Atari 8-bit computer]

 

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>

Arturo's '':logical'' values inherently support ternary logic (<code>true</code>, <code>false</code> and <code>maybe</code>) and the corresponding logical operations.

 

 

loop vals 'v -> print ["NOT" v "=>" not? v]

loop vals 'v2

-> print [v1 "XOR" v2 "=>" xor? v1 v2]

 

{{out}}

 

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

=={{header|BASIC256}}==

{{trans|Liberty BASIC}}

global tFalse, tDontKnow, tTrue

tFalse = 0

end case

end function

{{out}}

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

=={{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 sharp|C#}}==

 

/// <summary>

}

}

{{out}}

<pre>¬True = False

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

 

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

 

=={{header|Elena}}==

ELENA 5.0 :

import system'routines;

import system'collections;

}

}

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

 

 

Standard Forth defines flags 'false' as 0 and 'true' as -1 (all bits set). We thus define 'maybe' as 1 to keep standard binary logic as-is and seamlessly include ternary logic. We may have use truthtables but here functions are more fluid.

 

 

: tnot dup maybe <> if invert then ;

CR ." [IMPLY]" ' timply table2. CR

CR ." [EQUIV]" ' tequiv table2. CR

 

{{out}}

 

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

Note equivalence and implication are used as proof, they are solved using the basic set instead of a lookup.

Note Since we use a balanced range -1,0,1 multiplication equals EQU

unit ternarylogic;

 

end;

end.

{$mode objfpc}

uses

writeln('F|',tFalse >< tTrue:7, tFalse >< tMaybe:7,tFalse >< tFalse:7);

writeln;

<pre>

Output:

 

=={{header|FreeBASIC}}==

F=-1, M=0, T=1

end enum

outstr += " " + symbol(not(i))

print outstr

<pre>

(AND) ( OR) (EQV) (IMP) (NOT)

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

Here is a compact solution

trit = {false: 'F', maybe: 'U', true: 'T'}

nand = (a, b) => (a == trit.false || b == trit.false) ? trit.true : (a == trit.maybe || b == trit.maybe) ? trit.maybe : trit.false

iff = (a, b) => or(and(a, b), nor(a, b))

xor = (a, b) => not(iff(a, b))

... to test it

functor = {nand, and, or, nor, implies, iff, xor}

display = {nand: '⊼', and: '∧', or: '∨', nor: '⊽', implies: '⇒', iff: '⇔', xor: '⊻', not: '¬'}

}

console.log(log)

...Output:

NOT

¬F = F

T ⊼ U = U T ∧ U = U T ∨ U = T T ⊽ U = F T ⇒ U = U T ⇔ U = U T ⊻ U = U

T ⊼ T = F T ∧ T = T T ∨ T = T T ⊽ T = F T ⇒ T = T T ⇔ T = T T ⊻ T = F

 

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

 

With Julia 1.0 and the new type <tt>missing</tt>, three-value logic is implemented by default

 

using Printf

for (A, B) in Iterators.product(tril, tril)

@printf("%8s | %8s | %8s\n", A, B, A ⊃ B)

 

{{out}}

 

=={{header|Kotlin}}==

 

enum class Trit {

println()

}

 

{{out}}

{{works with|langur|0.6.12}}

 

val .trSet = [false, null, true]

 

writeln $"\.a:.F; \.b:.F; \.a ==? .b:.F;"

}

 

{{out}}

 

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

'ternary logic

'0 1 2

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

end function

 

{{out}}

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]

[ ]

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

 

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

echo "$# or $#: $#".format(op1, op2, op1 or op2)

echo "$# then $#: $#".format(op1, op2, op1.then op2)

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

File <TT>Trit.pm</TT>:

 

# -1 = false ; 0 = maybe ; 1 = true

sub or { new Trit(max(${$_[0]}, ${$_[1]}) ) }

 

File <TT>test.pl</TT>:

 

my @a = (TRUE(), MAYBE(), FALSE());

}

print "\n";

{{out}}

<pre>a NOT a

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">enum</span> <span style="color: #000000;">T</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">M</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">F</span>

<span style="color: #008080;">type</span> <span style="color: #000000;">ternary</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">T</span><span style="color: #0000FF;">,</span><span style="color: #000000;">M</span><span style="color: #0000FF;">,</span><span style="color: #000000;">F</span><span style="color: #0000FF;">})</span> <span style="color: #008080;">end</span> <span style="color: #008080;">type</span>

<span style="color: #000000;">show_truth_table</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t_implies</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"imp"</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">show_truth_table</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t_equal</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"eq"</span><span style="color: #0000FF;">)</span>

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

 

=={{header|Picat}}==

(show_op1('!') ; true),

nl,

nl

end,

 

{{out}}

 

===Simple examples===

println(ternary(10 > 3,'->',maybe).ternary('!')),

 

{{out}}

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

<pre>not T -> NIL

=={{header|PureBasic}}==

{{trans|FreeBasic}}

TLogic:

Data.i -1,0,1

Next

EndIf

{{out}}

<pre> (AND) ( OR) (EQV) (IMP) (NOT)

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

 

=={{header|Quackery}}==

[ 2 ] is maybe ( --> t )

say " false | " false true t.<=> paddedtrit sp

say "| " false maybe t.<=> paddedtrit sp

 

'''Output:'''

 

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

The precedence of each operator is specified as equivalent to an existing operator. We've taken the liberty of using a double arrow for implication, to avoid confusing it with <tt>⊃</tt>, (U+2283 SUPERSET OF).

 

enum Trit <Foo Moo Too>;

 

Foo ∧ Too ∨ Foo ⇒ Foo ≡ Too,

Foo ∧ Too ∨ Too ⇒ Foo ≡ Foo,

 

{{out}}

{{Works with|Red|0.6.4}}

 

 

; define trits as a set of 3 Red words: 'oui, 'non and 'bof

print rejoin [pad mold s 25 " " do s]

]

 

{{out}}

=={{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. */

otherwise return -13 /*error, unknown function.*/

end /*select*/

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

<br><br>

 

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

=={{header|Rust}}==

{{trans|Kotlin}}

 

#[derive(Copy, Clone, Debug)]

println!();

}

 

{{out}}

 

=={{header|Scala}}==

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

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

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

 

{{out}}

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

=={{header|True BASIC}}==

{{trans|BASIC256}}

FUNCTION and3(a, b)

IF a < b then LET and3 = a else LET and3 = b

NEXT a

END

{{out}}

<pre>

Below is an example of how this would look, which can be compared to traditional ternary usage:

 

 

fn main() {

fn ternary_equiv(a f64, b f64) string {

return if a == b {'1.'} else if a == 1 {b.str()} else if b == 1 {a.str()} else {'0.5'}

 

{{out}}

 

=={{header|Wren}}==

var Maybe = 0

var True = 1

for (u in trits) System.write("%(t == u) ")

System.print()

 

{{out}}

=={{header|Yabasic}}==

{{trans|BASIC256}}

tFalse = 0

tDontKnow = 1

next a

end

{{out}}

<pre>