The London Perl and Raku Workshop takes place on 26th Oct 2024. If your company depends on Perl, please consider sponsoring and/or attending.
 / 
Math-Logic-Ternary-0.004
River stage zero No dependents
/ Math::Logic::Ternary::Trit

NAME

Math::Logic::Ternary::Trit - ternary logical information unit

VERSION

This documentation refers to version 0.004 of Math::Logic::Ternary::Trit.

SYNOPSIS

use Math::Logic::Ternary::Trit;

$a = Math::Logic::Ternary::Trit->true;
$a = Math::Logic::Ternary::Trit->from_string('true'); # same as above
$a = Math::Logic::Ternary::Trit->from_int(1);         # same as above
$a = Math::Logic::Ternary::Trit->from_bool(1 == 1);   # same as above

$b = Math::Logic::Ternary::Trit->false;
$b = Math::Logic::Ternary::Trit->from_string('false'); # same as above
$b = Math::Logic::Ternary::Trit->from_int(-1);         # same as above
$b = Math::Logic::Ternary::Trit->from_bool(0 == 1);    # same as above

$c = Math::Logic::Ternary::Trit->nil;
$c = Math::Logic::Ternary::Trit->from_string('nil');  # same as above
$c = Math::Logic::Ternary::Trit->from_int(0);         # same as above
$c = Math::Logic::Ternary::Trit->from_bool(undef);    # same as above

$d = $a->and($b)->or($a->not->and($c));

print $d->as_string;                                  # print '$false'
print $d->as_int;                                     # print -1

DESCRIPTION

Math::Logic::Ternary::Trit is the class for ternary logical values aka trits. This class has only three instances, representing ternary truth values: true, false, and nil. It also implements logical operators, conversions and the role defined by Math::Logic::Ternary::Object.

Exports

None.

Constants

nil

The nil trit.

true

The true trit.

false

The false trit.

Unary Operators

sn

Set to nil.

+-------+-------+
|   A   | sn A  |
+-------+-------+
| false | nil   |
| nil   | nil   |
| true  | nil   |
+-------+-------+
st

Set to true.

+-------+-------+
|   A   | st A  |
+-------+-------+
| false | true  |
| nil   | true  |
| true  | true  |
+-------+-------+
sf

Set to false.

+-------+-------+
|   A   | sf A  |
+-------+-------+
| false | false |
| nil   | false |
| true  | false |
+-------+-------+
id

Identity.

+-------+-------+
|   A   | id A  |
+-------+-------+
| false | false |
| nil   | nil   |
| true  | true  |
+-------+-------+
not

Not.

+-------+-------+
|   A   | not A |
+-------+-------+
| false | true  |
| nil   | nil   |
| true  | false |
+-------+-------+
up

Up one: increment modulo 3.

+-------+-------+
|   A   | up A  |
+-------+-------+
| false | nil   |
| nil   | true  |
| true  | false |
+-------+-------+
nup

Not up: swap nil/false.

+-------+-------+
|   A   | nup A |
+-------+-------+
| false | nil   |
| nil   | false |
| true  | true  |
+-------+-------+
dn

Down one: decrement modulo 3.

+-------+-------+
|   A   | dn A  |
+-------+-------+
| false | true  |
| nil   | false |
| true  | nil   |
+-------+-------+
ndn

Not down: swap nil/true.

+-------+-------+
|   A   | ndn A |
+-------+-------+
| false | false |
| nil   | true  |
| true  | nil   |
+-------+-------+
eqn

Equal to nil.

+-------+-------+
|   A   | eqn A |
+-------+-------+
| false | false |
| nil   | true  |
| true  | false |
+-------+-------+
eqt

Equal to true.

+-------+-------+
|   A   | eqt A |
+-------+-------+
| false | false |
| nil   | false |
| true  | true  |
+-------+-------+
eqf

Equal to false.

+-------+-------+
|   A   | eqf A |
+-------+-------+
| false | true  |
| nil   | false |
| true  | false |
+-------+-------+
nen

Not equal to nil.

+-------+-------+
|   A   | nen A |
+-------+-------+
| false | true  |
| nil   | false |
| true  | true  |
+-------+-------+
net

Not equal to true.

+-------+-------+
|   A   | net A |
+-------+-------+
| false | true  |
| nil   | true  |
| true  | false |
+-------+-------+
nef

Not equal to false.

+-------+-------+
|   A   | nef A |
+-------+-------+
| false | false |
| nil   | true  |
| true  | true  |
+-------+-------+
hm

Hamlet: x or not x.

+-------+-------+
|   A   | hm A  |
+-------+-------+
| false | true  |
| nil   | nil   |
| true  | true  |
+-------+-------+
uhm

Up & hamlet.

+-------+-------+
|   A   | uhm A |
+-------+-------+
| false | nil   |
| nil   | true  |
| true  | true  |
+-------+-------+
dhm

Down & hamlet.

+-------+-------+
|   A   | dhm A |
+-------+-------+
| false | true  |
| nil   | true  |
| true  | nil   |
+-------+-------+
orn

Or nil.

+-------+-------+
|   A   | orn A |
+-------+-------+
| false | nil   |
| nil   | nil   |
| true  | true  |
+-------+-------+
uorn

Up & or nil.

+-------+--------+
|   A   | uorn A |
+-------+--------+
| false | nil    |
| nil   | true   |
| true  | nil    |
+-------+--------+
dorn

Down & or nil.

+-------+--------+
|   A   | dorn A |
+-------+--------+
| false | true   |
| nil   | nil    |
| true  | nil    |
+-------+--------+
qt

Quantum: x and not x.

+-------+-------+
|   A   | qt A  |
+-------+-------+
| false | false |
| nil   | nil   |
| true  | false |
+-------+-------+
uqt

Up & quantum.

+-------+-------+
|   A   | uqt A |
+-------+-------+
| false | nil   |
| nil   | false |
| true  | false |
+-------+-------+
dqt

Down & quantum.

+-------+-------+
|   A   | dqt A |
+-------+-------+
| false | false |
| nil   | false |
| true  | nil   |
+-------+-------+
ann

And nil.

+-------+-------+
|   A   | ann A |
+-------+-------+
| false | false |
| nil   | nil   |
| true  | nil   |
+-------+-------+
uann

Up & ann.

+-------+--------+
|   A   | uann A |
+-------+--------+
| false | nil    |
| nil   | nil    |
| true  | false  |
+-------+--------+
dann

Down & ann.

+-------+--------+
|   A   | dann A |
+-------+--------+
| false | nil    |
| nil   | false  |
| true  | nil    |
+-------+--------+

Binary Operators

and

And.

A and B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   false   false |
| nil   | false   nil     nil   |
| true  | false   nil     true  |
+-------+-----------------------+
or

Or.

A or B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   nil     true  |
| nil   | nil     nil     true  |
| true  | true    true    true  |
+-------+-----------------------+
xor

Exclusive or.

A xor B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   nil     true  |
| nil   | nil     nil     nil   |
| true  | true    nil     false |
+-------+-----------------------+
eqv

Equivalent.

A eqv B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | true    nil     false |
| nil   | nil     nil     nil   |
| true  | false   nil     true  |
+-------+-----------------------+
imp

Implication (x ==> y).

A imp B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | true    true    true  |
| nil   | nil     nil     true  |
| true  | false   nil     true  |
+-------+-----------------------+
rep

Replication (x <== y).

A rep B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | true    nil     false |
| nil   | true    nil     nil   |
| true  | true    true    true  |
+-------+-----------------------+
nand

Not and.

A nand B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | true    true    true  |
| nil   | true    nil     nil   |
| true  | true    nil     false |
+-------+-----------------------+
nor

Not or.

A nor B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | true    nil     false |
| nil   | nil     nil     false |
| true  | false   false   false |
+-------+-----------------------+
cmp

Compare (false < nil < true).

A cmp B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | nil     false   false |
| nil   | true    nil     false |
| true  | true    true    nil   |
+-------+-----------------------+
asc

Ascending (false < nil < true).

A asc B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | nil     true    true  |
| nil   | false   nil     true  |
| true  | false   false   nil   |
+-------+-----------------------+
tlr

The lesser (false < nil < true). Logically equivalent to and.

A tlr B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   false   false |
| nil   | false   nil     nil   |
| true  | false   nil     true  |
+-------+-----------------------+
tgr

The greater (false < nil < true). Logically equivalent to or.

A tgr B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   nil     true  |
| nil   | nil     nil     true  |
| true  | true    true    true  |
+-------+-----------------------+
eq

Equal to.

A eq B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | true    false   false |
| nil   | false   true    false |
| true  | false   false   true  |
+-------+-----------------------+
ne

Not equal to.

A ne B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   true    true  |
| nil   | true    false   true  |
| true  | true    true    false |
+-------+-----------------------+
lt

Less than (false < nil < true)

A lt B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   true    true  |
| nil   | false   false   true  |
| true  | false   false   false |
+-------+-----------------------+
ge

Greater or equal (false < nil < true).

A ge B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | true    false   false |
| nil   | true    true    false |
| true  | true    true    true  |
+-------+-----------------------+
gt

Greater than (false < nil < true).

A gt B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   false   false |
| nil   | true    false   false |
| true  | true    true    false |
+-------+-----------------------+
le

Less or equal (false < nil < true).

A le B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | true    true    true  |
| nil   | false   true    true  |
| true  | false   false   true  |
+-------+-----------------------+
cmpu

Compare (unbalanced, nil < true < false).

A cmpu B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     false   false |
| true  | true    nil     false |
| false | true    true    nil   |
+-------+-----------------------+
ascu

Ascending (unbalanced, nil < true < false).

A ascu B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     true    true  |
| true  | false   nil     true  |
| false | false   false   nil   |
+-------+-----------------------+
tlru

The lesser (unbalanced, nil < true < false).

A tlru B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     nil     nil   |
| true  | nil     true    true  |
| false | nil     true    false |
+-------+-----------------------+
tgru

The greater (unbalanced, nil < true < false).

A tgru B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     true    false |
| true  | true    true    false |
| false | false   false   false |
+-------+-----------------------+
ltu

Less than (unbalanced, nil < true < false).

A ltu B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | false   true    true  |
| true  | false   false   true  |
| false | false   false   false |
+-------+-----------------------+
geu

Greater or equal (unbalanced, nil < true < false).

A geu B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | true    false   false |
| true  | true    true    false |
| false | true    true    true  |
+-------+-----------------------+
gtu

Greater than (unbalanced, nil < true < false).

A gtu B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | false   false   false |
| true  | true    false   false |
| false | true    true    false |
+-------+-----------------------+
leu

Less or equal (unbalanced, nil < true < false).

A gtu B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | true    true    true  |
| true  | false   true    true  |
| false | false   false   true  |
+-------+-----------------------+
incr

Increment.

A incr B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | true    false   nil   |
| nil   | false   nil     true  |
| true  | nil     true    false |
+-------+-----------------------+
incc

Increment carry.

A incc B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   nil     nil   |
| nil   | nil     nil     nil   |
| true  | nil     nil     true  |
+-------+-----------------------+
inccu

Increment carry (unbalanced).

A inccu B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     nil     nil   |
| true  | nil     nil     true  |
| false | nil     true    true  |
+-------+-----------------------+
inccv

Increment carry (negative base).

A inccv B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     nil     true  |
| true  | nil     nil     nil   |
| false | nil     false   nil   |
+-------+-----------------------+
decr

Decrement.

A decr B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | nil     false   true  |
| nil   | true    nil     false |
| true  | false   true    nil   |
+-------+-----------------------+
decc

Decrement carry.

A decc B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | nil     nil     true  |
| nil   | nil     nil     nil   |
| true  | false   nil     nil   |
+-------+-----------------------+
deccu

Decrement carry (unbalanced).

A deccu B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     true    true  |
| true  | nil     nil     true  |
| false | nil     nil     nil   |
+-------+-----------------------+
deccv

Decrement carry (negative base)

A deccv B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     false   nil   |
| true  | nil     nil     nil   |
| false | nil     nil     true  |
+-------+-----------------------+
pty

Parity.

A pty B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   true    nil   |
| nil   | true    nil     false |
| true  | nil     false   true  |
+-------+-----------------------+
dpl

Duplicate.

A dpl B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | nil     true    false |
| nil   | false   nil     true  |
| true  | true    false   nil   |
+-------+-----------------------+
dplc

Duplication carry.

A dplc B
+---+---------------------------+
| A | B   false   nil     true  |
|   +---+-----------------------+
| false | false   false   nil   |
| nil   | nil     nil     nil   |
| true  | nil     true    true  |
+-------+-----------------------+
dplcu

Duplication carry (unbalanced).

A dplcu B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     nil     nil   |
| true  | nil     true    true  |
| false | true    true    false |
+-------+-----------------------+
dplcv

Duplication carry (negative base).

A dplcv B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     nil     true  |
| true  | nil     false   nil   |
| false | false   false   false |
+-------+-----------------------+
negcv

Negation carry (negative base).

A negcv B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     nil     nil   |
| true  | true    nil     nil   |
| false | true    true    nil   |
+-------+-----------------------+
mulcu

Multiplication carry (unbalanced).

A mulcu B
+---+---------------------------+
| A | B   nil     true    false |
|   +---+-----------------------+
| nil   | nil     nil     nil   |
| true  | nil     nil     nil   |
| false | nil     nil     true  |
+-------+-----------------------+

Ternary Operators

add

Addition.

add A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | nil     true    false |
| false | nil   | true    false   nil   |
| false | true  | false   nil     true  |
|       |       |                       |
| nil   | false | true    false   nil   |
| nil   | nil   | false   nil     true  |
| nil   | true  | nil     true    false |
|       |       |                       |
| true  | false | false   nil     true  |
| true  | nil   | nil     true    false |
| true  | true  | true    false   nil   |
+-------+-------+-----------------------+
addc

Addition carry.

addc A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | false   false   nil   |
| false | nil   | false   nil     nil   |
| false | true  | nil     nil     nil   |
|       |       |                       |
| nil   | false | false   nil     nil   |
| nil   | nil   | nil     nil     nil   |
| nil   | true  | nil     nil     true  |
|       |       |                       |
| true  | false | nil     nil     nil   |
| true  | nil   | nil     nil     true  |
| true  | true  | nil     true    true  |
+-------+-------+-----------------------+
addcu

Addition carry (unbalanced).

addcu A, B, C
+-------+---+---------------------------+
|   A   | B | C   nil     true    false |
|       |   +---+-----------------------+
| nil   | nil   | nil     nil     nil   |
| nil   | true  | nil     nil     true  |
| nil   | false | nil     true    true  |
|       |       |                       |
| true  | nil   | nil     nil     true  |
| true  | true  | nil     true    true  |
| true  | false | true    true    true  |
|       |       |                       |
| false | nil   | nil     true    true  |
| false | true  | true    true    true  |
| false | false | true    true    false |
+-------+-------+-----------------------+
addcv

Addition carry (negative base).

addcv A, B, C
+-------+---+---------------------------+
|   A   | B | C   nil     true    false |
|       |   +---+-----------------------+
| nil   | nil   | nil     nil     true  |
| nil   | true  | nil     nil     nil   |
| nil   | false | nil     false   nil   |
|       |       |                       |
| true  | nil   | nil     nil     nil   |
| true  | true  | nil     false   nil   |
| true  | false | false   false   nil   |
|       |       |                       |
| false | nil   | nil     false   nil   |
| false | true  | false   false   nil   |
| false | false | false   false   false |
+-------+-------+-----------------------+
addcx

Addition carry (mixed base).

For multiplication in base(-3), an addition of two trits 0..2 and one trit -1..1 can be useful. Addcx computes a signed carry trit for this kind of addition.

addcx A, B, C
+-------+---+---------------------------+
|   A   | B | C   nil     true    false |
|       |   +---+-----------------------+
| nil   | nil   | nil     nil     true  |
| nil   | true  | nil     nil     nil   |
| nil   | false | true    nil     true  |
|       |       |                       |
| true  | nil   | nil     nil     nil   |
| true  | true  | nil     false   nil   |
| true  | false | nil     nil     true  |
|       |       |                       |
| false | nil   | nil     false   nil   |
| false | true  | false   false   nil   |
| false | false | nil     nil     nil   |
+-------+-------+-----------------------+
subt

Subtraction.

subt A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | true    nil     false |
| false | nil   | nil     false   true  |
| false | true  | false   true    nil   |
|       |       |                       |
| nil   | false | false   true    nil   |
| nil   | nil   | true    nil     false |
| nil   | true  | nil     false   true  |
|       |       |                       |
| true  | false | nil     false   true  |
| true  | nil   | false   true    nil   |
| true  | true  | true    nil     false |
+-------+-------+-----------------------+
subc

Subtraction carry.

subc A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | nil     nil     nil   |
| false | nil   | nil     nil     true  |
| false | true  | nil     true    true  |
|       |       |                       |
| nil   | false | false   nil     nil   |
| nil   | nil   | nil     nil     nil   |
| nil   | true  | nil     nil     true  |
|       |       |                       |
| true  | false | false   false   nil   |
| true  | nil   | false   nil     nil   |
| true  | true  | nil     nil     nil   |
+-------+-------+-----------------------+
subcu

Subtraction carry (unbalanced).

subcu A, B, C
+-------+---+---------------------------+
|   A   | B | C   nil     true    false |
|       |   +---+-----------------------+
| nil   | nil   | nil     true    true  |
| nil   | true  | true    true    true  |
| nil   | false | true    true    false |
|       |       |                       |
| true  | nil   | nil     nil     true  |
| true  | true  | nil     true    true  |
| true  | false | true    true    true  |
|       |       |                       |
| false | nil   | nil     nil     nil   |
| false | true  | nil     nil     true  |
| false | false | nil     true    true  |
+-------+-------+-----------------------+
subcv

Subtraction carry (negative base).

subcv A, B, C
+-------+---+---------------------------+
|   A   | B | C   nil     true    false |
|       |   +---+-----------------------+
| nil   | nil   | nil     false   nil   |
| nil   | true  | false   false   nil   |
| nil   | false | false   false   false |
|       |       |                       |
| true  | nil   | nil     nil     nil   |
| true  | true  | nil     false   nil   |
| true  | false | false   false   nil   |
|       |       |                       |
| false | nil   | nil     nil     true  |
| false | true  | nil     nil     nil   |
| false | false | nil     false   nil   |
+-------+-------+-----------------------+
cmin

Ternary comparison to minimum.

cmin A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | nil     nil     nil   |
| false | nil   | nil     nil     nil   |
| false | true  | nil     false   false |
|       |       |                       |
| nil   | false | nil     nil     nil   |
| nil   | nil   | nil     nil     nil   |
| nil   | true  | true    false   false |
|       |       |                       |
| true  | false | true    true    false |
| true  | nil   | true    true    false |
| true  | true  | true    true    false |
+-------+-------+-----------------------+
cmed

Ternary comparison to median.

cmed A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | true    true    false |
| false | nil   | true    true    false |
| false | true  | true    nil     nil   |
|       |       |                       |
| nil   | false | true    true    false |
| nil   | nil   | true    true    false |
| nil   | true  | false   true    nil   |
|       |       |                       |
| true  | false | nil     nil     true  |
| true  | nil   | nil     nil     true  |
| true  | true  | false   false   true  |
+-------+-------+-----------------------+
cmax

Ternary comparison to maximum.

cmax A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | false   false   true  |
| false | nil   | false   false   true  |
| false | true  | false   true    true  |
|       |       |                       |
| nil   | false | false   false   true  |
| nil   | nil   | false   false   true  |
| nil   | true  | nil     nil     true  |
|       |       |                       |
| true  | false | false   false   nil   |
| true  | nil   | false   false   nil   |
| true  | true  | nil     nil     nil   |
+-------+-------+-----------------------+
cvld

Ternary comparison validation.

+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | true    true    true  |
| false | nil   | nil     nil     true  |
| false | true  | false   nil     true  |
|       |       |                       |
| nil   | false | true    nil     nil   |
| nil   | nil   | nil     true    nil   |
| nil   | true  | nil     nil     true  |
|       |       |                       |
| true  | false | true    nil     false |
| true  | nil   | true    nil     nil   |
| true  | true  | true    true    true  |
+-------+-------+-----------------------+
min

Minimum of three.

min A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | false   false   false |
| false | nil   | false   false   false |
| false | true  | false   false   false |
|       |       |                       |
| nil   | false | false   false   false |
| nil   | nil   | false   nil     nil   |
| nil   | true  | false   nil     nil   |
|       |       |                       |
| true  | false | false   false   false |
| true  | nil   | false   nil     nil   |
| true  | true  | false   nil     true  |
+-------+-------+-----------------------+
med

Median of three.

med A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | false   false   false |
| false | nil   | false   nil     nil   |
| false | true  | false   nil     true  |
|       |       |                       |
| nil   | false | false   nil     nil   |
| nil   | nil   | nil     nil     nil   |
| nil   | true  | nil     nil     true  |
|       |       |                       |
| true  | false | false   nil     true  |
| true  | nil   | nil     nil     true  |
| true  | true  | true    true    true  |
+-------+-------+-----------------------+
max

Maximum of three.

max A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | false   nil     true  |
| false | nil   | nil     nil     true  |
| false | true  | true    true    true  |
|       |       |                       |
| nil   | false | nil     nil     true  |
| nil   | nil   | nil     nil     true  |
| nil   | true  | true    true    true  |
|       |       |                       |
| true  | false | true    true    true  |
| true  | nil   | true    true    true  |
| true  | true  | true    true    true  |
+-------+-------+-----------------------+
minu

Minimum of three (unbalanced).

minu A, B, C
+-------+---+---------------------------+
|   A   | B | C   nil     true    false |
|       |   +---+-----------------------+
| nil   | nil   | nil     nil     nil   |
| nil   | true  | nil     nil     nil   |
| nil   | false | nil     nil     nil   |
|       |       |                       |
| true  | nil   | nil     nil     nil   |
| true  | true  | nil     true    true  |
| true  | false | nil     true    true  |
|       |       |                       |
| false | nil   | nil     nil     nil   |
| false | true  | nil     true    true  |
| false | false | nil     true    false |
+-------+-------+-----------------------+
medu

Median of three (unbalanced).

medu A, B, C
+-------+---+---------------------------+
|   A   | B | C   nil     true    false |
|       |   +---+-----------------------+
| nil   | nil   | nil     nil     nil   |
| nil   | true  | nil     true    true  |
| nil   | false | nil     true    false |
|       |       |                       |
| true  | nil   | nil     true    true  |
| true  | true  | true    true    true  |
| true  | false | true    true    false |
|       |       |                       |
| false | nil   | nil     true    false |
| false | true  | true    true    false |
| false | false | false   false   false |
+-------+-------+-----------------------+
maxu

Maximum of three (unbalanced).

maxu A, B, C
+-------+---+---------------------------+
|   A   | B | C   nil     true    false |
|       |   +---+-----------------------+
| nil   | nil   | nil     true    false |
| nil   | true  | true    true    false |
| nil   | false | false   false   false |
|       |       |                       |
| true  | nil   | true    true    false |
| true  | true  | true    true    false |
| true  | false | false   false   false |
|       |       |                       |
| false | nil   | false   false   false |
| false | true  | false   false   false |
| false | false | false   false   false |
+-------+-------+-----------------------+
ipqc

Interpolation quadratic coefficient.

In modulo 3 arithmetic, a polynomial with values A, B, C at positions 0, 1, 2 can be computed as -(A + B + C) * x * x + (C - B) * x + A. For that reason, the negated sum of three trits modulo 3 has got the funny name ipqc.

ipqc A, B, C
+-------+---+---------------------------+
|   A   | B | C   false   nil     true  |
|       |   +---+-----------------------+
| false | false | nil     false   true  |
| false | nil   | false   true    nil   |
| false | true  | true    nil     false |
|       |       |                       |
| nil   | false | false   true    nil   |
| nil   | nil   | true    nil     false |
| nil   | true  | nil     false   true  |
|       |       |                       |
| true  | false | true    nil     false |
| true  | nil   | nil     false   true  |
| true  | true  | false   true    nil   |
+-------+-------+-----------------------+

Quarternary Operators

sum

Summation.

A result trit and a carry trit can hold the sum of three operand trits and a carry trit. Thus, addition of three numerical values can be implemented efficiently in ternary arithmetic based on this super addition operator with four trit arguments.

sum A, B, C, D
+-------+---+---------------------------+
|   A   | B | C   f f f   n n n   t t t |
|       |   +---------------------------+
|       |   | D   f n t   f n t   f n t |
|       |   +---+-----------------------+
| false | false | f n t   n t f   t f n |
| false | nil   | n t f   t f n   f n t |
| false | true  | t f n   f n t   n t f |
|       |       |                       |
| nil   | false | n t f   t f n   f n t |
| nil   | nil   | t f n   f n t   n t f |
| nil   | true  | f n t   n t f   t f n |
|       |       |                       |
| true  | false | t f n   f n t   n t f |
| true  | nil   | f n t   n t f   t f n |
| true  | true  | n t f   t f n   f n t |
+-------+-------+-----------------------+
sumc

Summation carry.

sumc A, B, C, D
+-------+---+---------------------------+
|   A   | B | C   f f f   n n n   t t t |
|       |   +---------------------------+
|       |   | D   f n t   f n t   f n t |
|       |   +---+-----------------------+
| false | false | f f f   f f n   f n n |
| false | nil   | f f n   f n n   n n n |
| false | true  | f n n   n n n   n n t |
|       |       |                       |
| nil   | false | f f n   f n n   n n n |
| nil   | nil   | f n n   n n n   n n t |
| nil   | true  | n n n   n n t   n t t |
|       |       |                       |
| true  | false | f n n   n n n   n n t |
| true  | nil   | n n n   n n t   n t t |
| true  | true  | n n t   n t t   t t t |
+-------+-------+-----------------------+
sumcu

Summation carry (unbalanced).

sumcu A, B, C, D
+-------+---+---------------------------+
|   A   | B | C   n n n   t t t   f f f |
|       |   +---------------------------+
|       |   | D   n t f   n t f   n t f |
|       |   +---+-----------------------+
| nil   | nil   | n n n   n n t   n t t |
| nil   | true  | n n t   n t t   t t t |
| nil   | false | n t t   t t t   t t f |
|       |       |                       |
| true  | nil   | n n t   n t t   t t t |
| true  | true  | n t t   t t t   t t f |
| true  | false | t t t   t t f   t f f |
|       |       |                       |
| false | nil   | n t t   t t t   t t f |
| false | true  | t t t   t t f   t f f |
| false | false | t t f   t f f   f f f |
+-------+-------+-----------------------+
mpx

Multiplex. The first argument determines which one of the other arguments to return.

mpx A, B, C, D
+-------+---+---------------------------+
|   A   | B | C   n n n   t t t   f f f |
|       |   +---------------------------+
|       |   | D   n t f   n t f   n t f |
|       |   +---+-----------------------+
| nil   | nil   | n n n   n n n   n n n |
| nil   | true  | t t t   t t t   t t t |
| nil   | false | f f f   f f f   f f f |
|       |       |                       |
| true  | nil   | n n n   t t t   f f f |
| true  | true  | n n n   t t t   f f f |
| true  | false | n n n   t t t   f f f |
|       |       |                       |
| false | nil   | n t f   n t f   n t f |
| false | true  | n t f   n t f   n t f |
| false | false | n t f   n t f   n t f |
+-------+-------+-----------------------+
generic

$trit->generic($op_name, @args) evaluates a generic operator with the given arguments.

Generic operator names consist of a letter and a number of digits from 0 to 2. Each letter stands for an operator signature and determines the number of digits completely describing the operator. The digits are mapped to trits nil, true, false, as with from_int_u.

c - constant, 1 digit designating the constant. Example: c1 is equivalent to true.

u - unary operator, 3 digits designating the result from nil, true, false. Example: u021 is equivalent to not.

b - binary operator, 9 digits designating the result from 9 possible pairs of input trits. Example: b000021012 is equivalent to xor.

s - symmetric ternary operator, 10 digits designating the result from 10 possible combinations of input trits (only enumerating the lexically first instance of permutations). Example: s0122010120 is equivalent to add.

t - ternary operator, 27 digits designating the result from 27 possible triples of input trits (lexically sorted). Example: t000010002002000202010110000 is equivalent to subc.

q - symmetric quaternary operator, 15 digits designating the result from 15 possible combinations of input trits (only enumerating the lexically first instance of permutations). Example: q000102100211022 is equivalent to sumc.

Q - quaternary operator, 81 digits designating the result from 81 possible quadruples of input trits (lexically sorted).

Math::Logic::Ternary::Object Role Methods

Trit

Trit inspection: $trit->Trit($n) returns $trit if $n is 0, otherwise nil.

Trits

Trit inspection: $trit->Trits returns ($trit), a list with one element.

Rtrits

$trit->Rtrits returns an empty list if $trit is nil, otherwise ($trit), a list with one element.

Sign

$trit->Sign returns $trit.

as_int

$trit->as_int returns an integer number, 0 for nil, 1 for true, and -1 for false.

as_int_u
as_int_v
res_mod3

$trit->as_int_u returns an integer number, 0 for nil, 1 for true, and 2 for false. $trit->as_int_v does the same. $trit->res_mod3 does the same.

as_string

$trit->as_string returns a string, '$nil' for nil, '$true' for true, and '$false' for false.

is_equal

$trit->is_equal($obj) returns true if $trit->Rtrits and $obj->Rtrits are identical lists, otherwise false. This means a single trit is regarded as equal to itself and any word with the same least significant trit and no other non-nil trits.

Other Object Methods

Mpx

Multiplex. $trit->Mpx($case_n, $case_t, $case_f) with three arbitrary arguments returns $case_n if $trit is nil, $case_t if $trit is true, or $case_f if $trit is false.

is_nil

$trit->is_nil returns boolean true if $trit is nil, otherwise false.

is_true

$trit->is_true returns boolean true if $trit is true, otherwise false.

is_false

$trit->is_false returns boolean true if $trit is false, otherwise false.

as_bool

$trit->as_bool returns undef if $trit is nil, 1 (boolean true) if $trit is true, or an empty string (boolean false) if $trit is false.

as_modint

$trit->as_modint converts $trit to a Math::ModInt object, mapping nil to mod(0, 3), true to mod(1, 3), and false to mod(2, 3).

The Perl extension Math::ModInt (available on CPAN) must be installed for this to work, otherwise as_modint will raise a run-time exception.

Constructors

All constructors are class methods. They may raise an exception when called with unexpected arguments.

from_bool

Math::Logic::Ternary->from_bool($arg) returns nil if $arg is undefined, false if $arg is defined but false, or true if $arg is true.

from_sign

Math::Logic::Ternary->from_sign($int) returns nil if $int is zero, true if $int is positive, or false if $int is negative.

from_remainder

Math::Logic::Ternary->from_remainder($int) returns nil if $int is equivalent to 0 (modulo 3), true if $int is equivalent to 1 (modulo 3), or false if $int is equivalent to 2 (modulo 3).

from_int

Math::Logic::Ternary->from_int($int) returns nil if $int is 0, true if $int is 1, or false if $int is -1.

from_int_u

Math::Logic::Ternary->from_int_u($int) returns nil if $int is 0, true if $int is 1, or false if $int is 2.

from_string

Math::Logic::Ternary->from_string($str) returns nil if $str is 'nil' or '$nil', true if $str is 'true' or '$true', and false if $str is 'false' or '$false'.

from_modint

Math::Logic::Ternary->from_modint($obj) returns nil or true or false if $obj is a Math::ModInt object and $obj->modulus is 3. A residue of 0, 1, or 2 maps to nil, true, or false, respectively.

from_various

Math::Logic::Ternary->from_various($arg) guesses the type of its argument and calls one of the more specific constructors (but not from_remainder).

Other Class Methods

make_generic

Math::Logic::Ternary->make_generic($op_name) returns an operator coderef defined by a generic operator name. It can subsequently be called as a method on trits.

Example:

$foo = Math::Logic::Ternary::Trit->make_generic('b021210102');
$bar = true->$foo(false);     # $bar = nil
$bar = $foo->(true, false);   # $bar = nil

On the syntax of generic operator names, see "generic".

trit_operators

Math::Logic::Ternary->trit_operators returns a list of listrefs with all currently implemented named trit operators with these contents:

[$name, $min_args, $var_args, $ret_vals, $arithmetic]

$name is the name of the operator, $min_args is the minimum number of arguments, $var_args is the number of optional arguments, $ret_vals is the number of return values, $arithmetic is undefined unless the operator is an arithmetic operator belonging to balanced (= 0), unbalanced (= 1), or negative base (= 2) arithmetic.

Currently, $var_args will be 0 and $ret_vals will be 1 for all list entries. This may change in future releases.

DIAGNOSTICS

unknown operator name "%s"

"generic" or "make_generic" was called with an invalid operator name.

too few arguments, expected %d more

An operator was called with too few operands.

integer "%d" out of range %d..%d

A constructor taking an integer argument was called with an argument outside its defined range.

unknown trit name "%s"

"from_string" was called with an invalid trit name.

modular integer with modulus 3 expected

"from_modint" was called with an invalid argument, either a modular integer with a modulus other than 3 or not a Math::ModInt object at all.

cannot convert %s to a trit

"from_various" was called with an invalid argument.

perl extension Math::ModInt is not available

"as_modint" was called on a platform where Math::ModInt can not be loaded. Installing Math::ModInt from CPAN should resolve this problem.

SEE ALSO

Math::Logic::Ternary
Math::Logic::Ternary::Object
Math::Logic::Ternary::Word
Math::Logic::Ternary::Calculator

AUTHOR

Martin Becker <becker-cpan-mp@cozap.com>

COPYRIGHT AND LICENSE

Copyright (c) 2012-2017 by Martin Becker, Blaubeuren. All rights reserved.

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.8.0 or, at your option, any later version of Perl 5 you may have available.