tritlib 0.1.0__tar.gz

tritlib-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+**/__pycache__/
+*.py[codz]
+dist/
+wheels/
+.coverage

tritlib-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright © 2026, Eric Tellier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders X be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.

tritlib-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: tritlib
+Version: 0.1.0
+Summary: Balanced ternary arithmetic and multi-valued logic library
+Author-email: Eric Tellier <eric.tellier@newick.fr>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: balanced-ternary,base3,kleene-logic,ternary,trit
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# tritlib
+
+Balanced ternary arithmetic and multi-valued logic library for Python.
+
+## What is balanced ternary?
+
+Balanced ternary is a numeral system in base 3 where each digit (called a *trit*) takes values from {−1, 0, +1} instead of the conventional {0, 1, 2}. It allows representing negative numbers without a sign bit, and negation is as simple as inverting every trit. Donald Knuth called it *"perhaps the prettiest number system of all."*
+
+## Features
+
+- `Trit` — immutable single‑trit type with arithmetic and logic operators
+- `Trits` — arbitrary‑length balanced ternary integers
+- `Tryte` — fixed‑width ternary words
+- Multiple ternary logic systems: Kleene (K3), Łukasiewicz (L3), Heyting (HT) and more
+- Step‑by‑step arithmetic (carry propagation, partial products) for educational use
+- Pure Python, no dependencies, type‑hinted
+
+## Installation
+
+```bash
+pip install tritlib
+```
+
+## Quick start
+
+```python
+from tritlib.trit import Trit, P, Z, N
+
+# Create trits
+t = Trit(1)   # +1
+print(t)       # "+"
+print(-t)      # "-"
+
+# Predefined constants
+assert P == Trit(1)
+assert Z == Trit(0)
+assert N == Trit(-1)
+```
+
+## Roadmap
+
+- [x] `Trit` type with immutability, arithmetic, hashing
+- [x] Trit‑level logic (Kleene K3)
+- [x] `Trits` arbitrary‑precision integers
+- [x] `Tryte` fixed‑width words
+- [x] Additional logic systems (L3, HT, BI3, Post)
+- [ ] Conversion utilities (int, str, float, binary‑coded ternary)
+- [ ] Educational step‑by‑step computation output
+
+## Development
+
+```bash
+git clone https://codeberg.org/newick_2/tritlib.git
+cd tritlib
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+python -m pytest
+```
+
+## License
+
+MIT License — see LICENSE file for details.

tritlib-0.1.0/README.md

@@ -0,0 +1,63 @@
+# tritlib
+
+Balanced ternary arithmetic and multi-valued logic library for Python.
+
+## What is balanced ternary?
+
+Balanced ternary is a numeral system in base 3 where each digit (called a *trit*) takes values from {−1, 0, +1} instead of the conventional {0, 1, 2}. It allows representing negative numbers without a sign bit, and negation is as simple as inverting every trit. Donald Knuth called it *"perhaps the prettiest number system of all."*
+
+## Features
+
+- `Trit` — immutable single‑trit type with arithmetic and logic operators
+- `Trits` — arbitrary‑length balanced ternary integers
+- `Tryte` — fixed‑width ternary words
+- Multiple ternary logic systems: Kleene (K3), Łukasiewicz (L3), Heyting (HT) and more
+- Step‑by‑step arithmetic (carry propagation, partial products) for educational use
+- Pure Python, no dependencies, type‑hinted
+
+## Installation
+
+```bash
+pip install tritlib
+```
+
+## Quick start
+
+```python
+from tritlib.trit import Trit, P, Z, N
+
+# Create trits
+t = Trit(1)   # +1
+print(t)       # "+"
+print(-t)      # "-"
+
+# Predefined constants
+assert P == Trit(1)
+assert Z == Trit(0)
+assert N == Trit(-1)
+```
+
+## Roadmap
+
+- [x] `Trit` type with immutability, arithmetic, hashing
+- [x] Trit‑level logic (Kleene K3)
+- [x] `Trits` arbitrary‑precision integers
+- [x] `Tryte` fixed‑width words
+- [x] Additional logic systems (L3, HT, BI3, Post)
+- [ ] Conversion utilities (int, str, float, binary‑coded ternary)
+- [ ] Educational step‑by‑step computation output
+
+## Development
+
+```bash
+git clone https://codeberg.org/newick_2/tritlib.git
+cd tritlib
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+python -m pytest
+```
+
+## License
+
+MIT License — see LICENSE file for details.

tritlib-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "tritlib"
+version = "0.1.0"
+description = "Balanced ternary arithmetic and multi-valued logic library"
+readme = "README.md"
+license = "MIT"
+requires-python = ">= 3.10"
+authors = [
+  { name = "Eric Tellier", email = "eric.tellier@newick.fr"}
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Typing :: Typed",
+]
+keywords = ["ternary", "balanced-ternary", "trit", "base3", "kleene-logic"]
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-cov"]

tritlib-0.1.0/src/tritlib/__init__.py

@@ -0,0 +1,13 @@
+"""
+tritlib: A Python library for trinary arithmetic and logic operations.
+
+This package provides classes for working with trits (ternary digits), trits numbers, and fixed-width trytes.
+It supports arithmetic operations, comparisons, and conversions between strings, integers, and trits.
+"""
+
+from .trit import Trit, N, Z, P
+from .trits import Trits
+from .tryte import Tryte
+from .logic import Lukasiewicz, RM3, BI3, HT, Kleene
+
+__all__ = ["Trit", "Trits", "Tryte", "N", "Z", "P", "Lukasiewicz", "RM3", "BI3", "HT", "Kleene"]

tritlib-0.1.0/src/tritlib/logic/__init__.py

@@ -0,0 +1,14 @@
+"""
+tritlib.logic: Ternary logic operations.
+
+This subpackage provides implementations of various ternary logic systems:
+Lukasiewicz, RM3, BI3, Heyting, and Kleene.
+"""
+
+from .lukasiewicz import Lukasiewicz
+from .rm3 import RM3
+from .bi3 import BI3
+from .heyting import HT
+from .kleene import Kleene
+
+__all__ = ["Lukasiewicz", "RM3", "BI3", "HT", "Kleene"]

tritlib-0.1.0/src/tritlib/logic/base.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from tritlib import Trit
+class TernaryLogic(ABC):
+    """
+    Abstract base class for ternary logic operations.
+    Defines methods for logical NOT, AND, OR, and IMPLY operations on trits.
+    Subclasses must implement the `imply_op` method.
+
+    Methods:
+        not_op(a): Returns the logical NOT of a trit.
+        and_op(a, b): Returns the logical AND of two trits.
+        or_op(a, b): Returns the logical OR of two trits.
+        imply_op(a, b): Abstract method for logical implication (to be implemented by subclasses).
+    """
+
+    def not_op(self, a: Trit) -> Trit: 
+        return -a
+
+    def and_op(self, a: Trit, b: Trit) -> Trit: 
+        return a & b
+    
+    def or_op(self, a: Trit, b: Trit) -> Trit: 
+        return a | b
+
+    @abstractmethod
+    def imply_op(self, a: Trit, b: Trit) -> Trit: ...
+
+

tritlib-0.1.0/src/tritlib/logic/bi3.py

@@ -0,0 +1,35 @@
+from tritlib.logic.base import TernaryLogic
+from tritlib import N, P,Z, Trit
+
+class BI3(TernaryLogic):
+    """
+    Implements BI3 ternary logic operations.
+    Provides specific implementations for logical AND, OR, and IMPLY operations.
+
+    Methods:
+        and_op(a, b): Returns the BI3 logical AND of two trits.
+        or_op(a, b): Returns the BI3 logical OR of two trits.
+        imply_op(a, b): Returns the BI3 logical implication of two trits.
+    """
+    def and_op(self, a: Trit, b: Trit) -> Trit:
+        if a == N or b == N or (a == b == Z):
+            return N
+        elif a == b == P:
+            return P
+        return Z
+
+    def imply_op(self, a: Trit, b: Trit) -> Trit:
+        print(f"BI3.imply_op called: a={a} ({a.value}), b={b} ({b.value}), b==Z: {b==Z}")
+        if a == Z or b == Z:
+            return Z
+        elif b == P:
+            return P
+        else:
+            return -a
+
+    def or_op(self, a: Trit, b: Trit) -> Trit:
+        if a == b == N :
+            return N
+        if a == P or b == P or (a == b == Z):
+            return P
+        return Z

tritlib-0.1.0/src/tritlib/logic/heyting.py

@@ -0,0 +1,25 @@
+from tritlib.logic.base import TernaryLogic
+from tritlib.trit import N, P,Z, Trit
+
+
+class HT(TernaryLogic):
+    """
+    Implements Heyting ternary logic operations.
+    Provides specific implementations for logical NOT and IMPLY operations.
+
+    Methods:
+        not_op(a): Returns the Heyting logical NOT of a trit.
+        imply_op(a, b): Returns the Heyting logical implication of two trits.
+    """
+    def not_op(self, a:Trit) -> Trit:
+        return P if a == N else N
+
+    def imply_op(self, a: Trit, b: Trit) -> Trit:
+        print("HT")
+        if b == P:
+            return P
+        elif b == Z:
+            return Z if a == P else P
+        else :
+            return self.not_op(a)
+

tritlib-0.1.0/src/tritlib/logic/kleene.py

@@ -0,0 +1,14 @@
+from tritlib.logic.base import TernaryLogic
+from tritlib.trit import Trit
+
+
+class Kleene(TernaryLogic):
+    """
+    Implements Kleene ternary logic operations.
+    Provides a specific implementation for the logical IMPLY operation.
+
+    Methods:
+        imply_op(a, b): Returns the Kleene logical implication of two trits.
+    """
+    def imply_op(self, a: Trit, b: Trit) -> Trit:
+        return -a | b

tritlib-0.1.0/src/tritlib/logic/lukasiewicz.py

@@ -0,0 +1,22 @@
+from tritlib.logic.base import TernaryLogic
+from tritlib.trit import Trit, P, Z
+
+
+class Lukasiewicz(TernaryLogic):
+    """
+    Implements Lukasiewicz ternary logic operations.
+    Provides specific implementations for logical NOT and IMPLY operations.
+
+    Methods:
+        not_op(a): Returns the Lukasiewicz logical NOT of a trit.
+        imply_op(a, b): Returns the Lukasiewicz logical implication of two trits.
+    """
+    def not_op(self, a: Trit) -> Trit:
+        return -a
+
+    def imply_op(self, a: Trit, b: Trit) -> Trit:
+        if a == b == Z:
+            return P
+        else:
+            return -a | b
+

tritlib-0.1.0/src/tritlib/logic/rm3.py

@@ -0,0 +1,23 @@
+from tritlib.logic.base import TernaryLogic
+from tritlib.trit import Trit, P, Z, N
+
+class RM3(TernaryLogic):
+    """
+    Implements RM3 ternary logic operations.
+    Provides specific implementations for logical NOT and IMPLY operations.
+
+    Methods:
+        not_op(a): Returns the RM3 logical NOT of a trit.
+        imply_op(a, b): Returns the RM3 logical implication of two trits.
+    """
+    def imply_op(self, a: Trit, b: Trit) -> Trit:
+        if b == P :
+            return P
+        elif b == Z:
+            return -a
+        else :
+            return P if a == N else N
+       
+
+    def not_op(self, a: Trit) -> Trit:
+        return -a

tritlib-0.1.0/src/tritlib/trit.py

@@ -0,0 +1,113 @@
+from functools import total_ordering
+
+@total_ordering
+class Trit:
+    """
+    Represents an immutable trinary digit (trit) with possible values: N (-1), Z (0), or P (1).
+    Provides arithmetic and logical operations for trits, including addition, multiplication,
+    negation, and bitwise operations.
+
+    Attributes:
+        _value (int): Internal value of the trit (-1, 0, or 1).
+
+    Properties:
+        value (int): Returns the integer value of the trit.
+
+    Methods:
+        __repr__(): Returns the official string representation of the trit.
+        __str__(): Returns the user-friendly string representation ('-', '0', or '+').
+        __eq__(other): Checks equality with another trit.
+        __hash__(): Returns the hash of the trit.
+        __neg__(): Returns the negation of the trit.
+        __mul__(other): Multiplies two trits.
+        half_add(other): Performs a half-addition with another trit, returning sum and carry.
+        full_add(other, carry): Performs a full-addition with another trit and a carry, returning sum and carry.
+        __invert__(): Returns the negation of the trit (alias for __neg__).
+        __and__(other): Returns the logical AND of two trits (minimum value).
+        __or__(other): Returns the logical OR of two trits (maximum value).
+        __lt__(other): Compares two trits for ordering.
+
+    Constants:
+        N (Trit): Represents the trit value -1.
+        Z (Trit): Represents the trit value 0.
+        P (Trit): Represents the trit value 1.
+    """
+    __slots__ = ("_value",)
+
+    def __init__(self, value: int):
+        if not -2 < value < 2:
+            raise ValueError
+
+        object.__setattr__(self,"_value", value)
+
+    def __repr__(self) -> str:
+        return f"Trit({self._value})"
+
+    def __str__(self) -> str:
+        if self._value > 0:
+            return "+"
+        elif self._value == 0:
+            return "0"
+        else :
+            return "-"
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Trit):
+            return NotImplemented
+        return self.value == other.value
+
+    def __hash__(self) -> int:
+        return hash(self._value)
+
+    def __setattr__(self, name, value):
+        raise AttributeError("Trit is immutable")
+
+    @property
+    def value(self) -> int:
+        return self._value
+
+    def __neg__(self) :
+        return Trit(-self._value)
+
+    def __mul__(self, other) :
+        if not isinstance(other, Trit):
+            return NotImplemented
+        return Trit(self.value * other.value)
+
+    def half_add(self, other):
+        if not isinstance(other, Trit):
+            return NotImplemented
+        if self.value == other.value :
+            s = -self
+            c = self
+        else:
+            s = Trit(self.value + other.value)
+            c = Z
+        return (s,c)
+
+    def full_add(self, other, carry):
+        if not (isinstance(other, Trit) and isinstance(carry, Trit)):
+            return NotImplemented
+        s1, c1 = self.half_add(other)
+        s2, c2 = s1.half_add(carry)
+        return s2, Trit(c1.value+c2.value)
+
+    def __invert__(self):
+        return self.__neg__()
+
+    def __and__(self, other):
+        if not isinstance(other, Trit):
+            return NotImplemented
+        return Trit(min(self._value, other._value))
+
+    def __or__(self, other):
+        if not isinstance(other, Trit):
+            return NotImplemented
+        return Trit(max(self._value, other._value))
+
+    def __lt__(self, other):
+        return self.value < other.value
+        
+N = Trit(-1)
+Z = Trit(0)
+P = Trit(1)

tritlib-0.1.0/src/tritlib/trits.py

@@ -0,0 +1,215 @@
+from functools import total_ordering
+from typing import Tuple
+from tritlib.trit import Trit, N, Z, P
+from itertools import zip_longest
+
+def _str_to_trits(s: str):
+    trit_dict = {"+": P, "-": N, "0": Z}
+    trits = []
+    for char in reversed(s):
+        if char not in trit_dict:
+            raise ValueError
+        else:
+            trits.append(trit_dict.get(char))
+    return trits
+
+@total_ordering
+class Trits:
+    """
+    Represents an immutable number in a balanced ternary system using trits (ternary digits: P, Z, N).
+    Supports arithmetic operations, comparisons, and conversions between strings and integers.
+
+    Attributes:
+        _trits (tuple[Trit]): Internal tuple of Trit objects representing the number.
+
+    Class Methods:
+        _from_trits(trits): Creates a Trits object from a list of Trit objects.
+        _from_le_trits(trits): Creates a Trits object from a list of Trit objects in little-endian order.
+        from_str(str_value): Creates a Trits object from a string representation (e.g., "+-0").
+
+    Properties:
+        _le_trits (list[Trit]): Returns the trits in little-endian order.
+
+    Methods:
+        __hash__(): Returns the hash of the Trits object.
+        __str__(): Returns the string representation of the Trits number.
+        __init__(n): Initializes a Trits object from a string or integer.
+        __eq__(other): Checks equality with another Trits object.
+        __lt__(other): Compares two Trits objects for ordering.
+        __add__(other): Adds two Trits numbers.
+        __sub__(other): Subtracts two Trits numbers.
+        __mul__(other): Multiplies two Trits numbers.
+        __floordiv__(other): Performs floor division between two Trits numbers.
+        to_int(): Converts the Trits number to an integer.
+
+    Usage:
+        >>> trits = Trits.from_str("+-0")
+        >>> print(trits)
+        +-0
+    """
+    __slots__ = ("_trits",)
+
+    def __hash__(self) -> int:
+        return hash(self._trits)
+
+    def __setattr__(self, name, value):
+        raise AttributeError("Trits is immutable")
+    
+    @classmethod
+    def _from_trits(cls, trits: list[Trit]):
+        while len(trits)>1 and trits[-1] == Z:
+            trits.pop()
+        obj = cls.__new__(cls)
+        if len(trits) == 0:
+            trits = [Z]
+        object.__setattr__(obj,"_trits",tuple(trits))
+        return obj
+
+    @classmethod
+    def _from_le_trits(cls, trits: list[Trit]):
+        trits.reverse()
+        return cls._from_trits(trits)
+
+    @property
+    def _le_trits(self):
+        a = list(self.trits)
+        a.reverse()
+        return a
+
+    @classmethod 
+    def from_str(cls, str_value: str):
+        return cls._from_trits(_str_to_trits(str_value))
+
+    def __str__(self):
+        trit_dict = {P: "+", N: "-", Z: "0"}
+        return "".join(trit_dict[t] for t in reversed(self._trits))
+
+    def __init__(self, n):
+        if isinstance(n, str):
+            object.__setattr__(self, "_trits", tuple(_str_to_trits(n)))
+        elif isinstance(n, int):
+            if n == 0:
+                object.__setattr__(self, "_trits", (Z,))
+                return
+            _trits = []
+            while n != 0:
+                n, r = divmod(n, 3)
+                if r == 2 :
+                    n += 1
+                    _trits.append(N)
+                elif r == 1:
+                    _trits.append(P)
+                else :
+                    _trits.append(Z)
+            object.__setattr__(self, "_trits", tuple(_trits))
+        else:
+            return NotImplemented
+            
+    def __repr__(self):
+        return f"Trits(\"{str(self)}\")"
+    
+    def __int__(self) -> int:
+        acc = 0
+        # Horner's method
+        for trit in reversed(self._trits):
+            acc = acc * 3 + trit.value
+
+        return acc
+
+    def __list__(self) -> list:
+        return list(self._trits)
+
+    @property
+    def trits(self) -> Tuple[Trit]:
+        return self._trits
+
+    def __eq__(self, other):
+        if not isinstance(other, Trits):
+            return NotImplemented
+        return self.trits == other.trits
+
+
+    def __add__(self, other):
+        if not isinstance(other, Trits):
+            return NotImplemented
+        _trits = []
+        c = Z
+        for a,b in zip_longest(self.trits, other.trits, fillvalue=Z):
+            s, c = a.full_add(b, c)
+            _trits.append(s)
+        if c != Z:
+            _trits.append(c)
+        return Trits._from_trits(_trits)
+
+    def __neg__(self):
+        return Trits._from_trits([-t for t in self._trits])
+
+    def __sub__(self, other):
+        if not isinstance(other, Trits):
+            return NotImplemented
+        return self + -other
+
+    def __mul__(self, other):
+        if not isinstance(other, Trits):
+            return NotImplemented
+        result = Trits._from_trits([Z])
+        for i,t in enumerate(self._trits):
+            if t == Z:
+                continue
+            partial = [Z] * i + [t*a for a in other._trits]
+            p = Trits._from_trits(partial)
+            result = result + p
+        return result
+
+    def __len__(self):
+        return len(self._trits)
+
+    def __lt__(self, other):
+        if not isinstance(other, Trits):
+            return NotImplemented
+        if len(self) < len(other):
+            return other.trits[-1] == P
+        elif len(self) > len(other):
+            return self.trits[-1] == N 
+        else:
+            for t1, t2 in zip(reversed(self.trits), reversed(other.trits)):
+                if t1 < t2:
+                    return True
+                elif t1 > t2:
+                    return False
+            return False
+
+    def __divmod__(self, other):
+        if not isinstance(other, Trits):
+            return NotImplemented
+        if other == Trits(0):
+            raise ZeroDivisionError
+        if self._trits == (Z,):
+            return Trits(0), Trits(0)
+        if len(self) < len(other):
+            return Trits(0), self 
+
+        s = self._le_trits
+        d = other._le_trits
+        partial_rest = s[:len(d)-1]
+        rem = s[len(d)-1:]
+        q = []
+        while len(rem) > 0:
+            partial_rest += [rem.pop(0)]
+            if d[0]*partial_rest[0] == P:
+                q.append(P)
+                pr = Trits._from_le_trits(partial_rest) - other
+                partial_rest = pr._le_trits
+            elif d[0]*partial_rest[0] == N:
+                q.append(N)
+                pr = Trits._from_le_trits(partial_rest) + other
+                partial_rest = pr._le_trits
+            else:
+                q.append(Z)
+        return Trits._from_le_trits(q), Trits._from_le_trits(partial_rest)
+
+    def __floordiv__(self, other):
+        return divmod(self, other)[0]
+       
+    def __mod__(self, other):
+        return divmod(self, other)[1]

tritlib-0.1.0/src/tritlib/tryte.py

@@ -0,0 +1,217 @@
+from functools import total_ordering
+from tritlib.trits import Trits
+from tritlib.trit import Z, N, P, Trit
+
+@total_ordering
+class Tryte:
+    """
+    Represents a fixed-width trit-based number system (tryte).
+    Supports arithmetic operations, comparisons, and conversions between trits and integers.
+    The class is immutable and handles overflow by truncating to the specified width.
+
+    Attributes:
+        _trits (tuple[Trit]): Internal tuple of Trit objects representing the tryte.
+        _width (int): Fixed width of the tryte.
+
+    Properties:
+        width (int): Returns the width of the tryte.
+        trits (list[Trit]): Returns the list of Trit objects representing the tryte.
+        _le_trits (list[Trit]): Returns the trits in little-endian order.
+
+    Class Methods:
+        _from_trits(trits, width): Creates a Tryte object from a list of Trit objects and a width.
+        from_le_trits(trits, width): Creates a Tryte object from a list of Trit objects in little-endian order and a width.
+
+    Methods:
+        __hash__(): Returns the hash of the Tryte object.
+        __init__(value, width): Initializes a Tryte object from a value (int or Trits) and a width.
+        __int__(): Converts the Tryte number to an integer.
+        to_trits(): Converts the Tryte object to a Trits object.
+        resize(width): Returns a new Tryte object with the specified width.
+        __len__(): Returns the number of trits in the tryte.
+        __eq__(other): Checks equality with another Tryte object.
+        __lt__(other): Compares two Tryte objects for ordering.
+        __repr__(): Returns the official string representation of the Tryte object.
+        __str__(): Returns the string representation of the Tryte number.
+        __add__(other): Adds two Tryte numbers.
+        __neg__(): Returns the negation of the Tryte number.
+        __sub__(other): Subtracts two Tryte numbers.
+        __mul__(other): Multiplies two Tryte numbers.
+        add_with_carry(other): Adds two Tryte numbers and returns the result and carry flag.
+        __divmod__(other): Performs division and modulus operations between two Tryte numbers.
+        __floordiv__(other): Performs floor division between two Tryte numbers.
+        __mod__(other): Performs modulus operation between two Tryte numbers.
+
+    Usage:
+        >>> tryte = Tryte(10, 5)
+        >>> print(tryte)
+        +-000
+    """
+    __slots__ = ("_trits", "_width")
+
+    def __hash__(self) -> int:
+        return hash(self._trits)
+
+    def __setattr__(self, name, value):
+        raise AttributeError("Trits is immutable")
+
+    def __init__(self, value, width: int):
+        trits = Trits(value)
+        if len(trits) > width:
+            raise OverflowError
+        else:
+            trits = list(trits.trits) + [Z] * (width - len(trits.trits))
+        object.__setattr__(self, "_trits", tuple(trits))
+        object.__setattr__(self, "_width", width)
+
+    @classmethod
+    def _from_trits(cls, trits: list[Trit], width: int):
+        # Do not raise OverflowError to simulate hardware behaviour
+        trits = trits + [Z]*(width - len(trits))
+        obj = cls.__new__(cls)
+        object.__setattr__(obj,"_trits",tuple(trits[:width]))
+        object.__setattr__(obj,"_width",width)
+        return obj 
+
+    @property
+    def width(self) -> int:
+        return self._width
+
+    def __int__(self) -> int:
+        acc = 0
+        # Horner's method
+        for trit in reversed(self._trits):
+            acc = acc * 3 + trit.value
+        return acc
+
+    @property
+    def trits(self) -> list[Trit]:
+        return list(self._trits)
+
+    def to_trits(self) -> Trits:
+        s = self.trits
+        while s[-1] == Z and len(s)>1:
+            s= s[:-1]
+        return Trits._from_trits(s)
+
+    @property    
+    def _le_trits(self) -> list[Trit]:
+        s = list(self.trits)
+        r = []
+        while len(s)>0:
+            a = s.pop()
+            if len(r) == 0 and a == Z:
+                continue
+            r.append(a)
+        return [Z] if len(r) == 0 else r
+
+    @classmethod
+    def from_le_trits(cls, trits: list[Trit], width: int):
+        trits.reverse()
+        return cls._from_trits(trits, width)
+
+    def resize(self, width):
+        return Tryte._from_trits(self.trits, width)
+
+    def __len__(self) -> int:
+        return len(self._trits)
+
+    def __eq__(self, other) -> bool:
+        if len(self) != len(other):
+            raise ValueError
+        return self.trits == other.trits
+
+    def __lt__(self, other):
+        if len(self) != len(other):
+            raise ValueError
+        for t1, t2 in zip(reversed(self.trits), reversed(other.trits)):
+            if t1 < t2:
+                return True
+            elif t1 > t2:
+                return False
+        return False
+
+    def __repr__(self):
+        return f'Tryte({int(self)}, {self.width})'
+    
+        
+    def __str__(self):
+        trit_dict = {P: "+", N: "-", Z: "0"}
+        return "".join(trit_dict[t] for t in reversed(self._trits))
+
+    def __add__(self, other):
+        if not isinstance(other, Tryte):
+            return NotImplemented
+        if len(self) != len(other):
+            raise ValueError
+        _trits = []
+        c = Z
+        for a,b in zip(self.trits, other.trits):
+            s, c = a.full_add(b, c)
+            _trits.append(s)
+        return Tryte._from_trits(_trits, self.width)
+
+    def __neg__(self):
+        return Tryte._from_trits([-t for t in self.trits], self.width)
+
+    def __sub__(self, other):
+        return self + -other
+
+    def __mul__(self, other):
+        if not isinstance(other, Tryte):
+            return NotImplemented
+        result = Tryte._from_trits([Z], self.width)
+        for i,t in enumerate(self._trits):
+            if t == Z:
+                continue
+            partial = [Z] * i + [t*a for a in other._trits]
+            p = Tryte._from_trits(partial, self.width)
+            result = result + p
+        return Tryte._from_trits(list(result.trits), self.width)
+
+    def add_with_carry(self, other):
+        if not isinstance(other, Tryte):
+            return NotImplemented
+        if len(self) != len(other):
+            raise ValueError
+        _trits = []
+        c = Z
+        for a,b in zip(self.trits, other.trits):
+            s, c = a.full_add(b, c)
+            _trits.append(s)
+        return Tryte._from_trits(_trits, self.width), (c != Z)
+
+    def __divmod__(self, other):
+        if not isinstance(other, Tryte):
+            return NotImplemented
+        if other == Tryte(0, self.width):
+            raise ZeroDivisionError
+        if self == Tryte(0, self.width):
+            return Tryte(0, self.width), Tryte(0, self.width)
+        if len(self) < len(other):
+            return Tryte(0, self.width), self 
+
+        s = self._le_trits
+        d = other._le_trits
+        partial_rest = s[:len(d)-1]
+        rem = s[len(d)-1:]
+        q = []
+        while len(rem) > 0:
+            partial_rest += [rem.pop(0)]
+            if d[0]*partial_rest[0] == P:
+                q.append(P)
+                pr = Tryte.from_le_trits(partial_rest, self.width) - other
+                partial_rest = pr._le_trits
+            elif d[0]*partial_rest[0] == N:
+                q.append(N)
+                pr = Tryte.from_le_trits(partial_rest, self.width) + other
+                partial_rest = pr._le_trits
+            else:
+                q.append(Z)
+        return Tryte.from_le_trits(q, self.width), Tryte.from_le_trits(partial_rest, self.width)
+
+    def __floordiv__(self, other):
+        return divmod(self, other)[0]
+       
+    def __mod__(self, other):
+        return divmod(self, other)[1]

tritlib-0.1.0/tests/test_logic.py

@@ -0,0 +1,92 @@
+from tritlib import Z, N, P, RM3, BI3, Lukasiewicz, HT, Kleene
+
+def test_logic_kleene():
+    logic = Kleene()
+    assert logic.and_op(N,P) == N
+
+def test_kleene_imply():
+    logic = Kleene()
+    assert logic.imply_op(N,N) == P
+    assert logic.imply_op(Z,N) == Z
+    assert logic.imply_op(P,N) == N
+    assert logic.imply_op(N,Z) == P
+    assert logic.imply_op(Z,Z) == Z
+    assert logic.imply_op(P,Z) == Z
+    assert logic.imply_op(N,P) == P
+    assert logic.imply_op(Z,P) == P
+    assert logic.imply_op(P,P) == P
+
+def test_lukasiewicz_imply():
+    logic = Lukasiewicz()
+    assert logic.imply_op(N,N) == P
+    assert logic.imply_op(Z,N) == Z
+    assert logic.imply_op(P,N) == N
+    assert logic.imply_op(N,Z) == P
+    assert logic.imply_op(Z,Z) == P
+    assert logic.imply_op(P,Z) == Z
+    assert logic.imply_op(N,P) == P
+    assert logic.imply_op(Z,P) == P
+    assert logic.imply_op(P,P) == P
+
+def test_heyting():
+    logic = HT()
+    assert logic.not_op(N) == P
+    assert logic.not_op(Z) == N
+    assert logic.not_op(P) == N
+
+
+    assert logic.imply_op(N,N) == P
+    assert logic.imply_op(Z,N) == N
+    assert logic.imply_op(P,N) == N
+    assert logic.imply_op(N,Z) == P
+    assert logic.imply_op(Z,Z) == P
+    assert logic.imply_op(P,Z) == Z
+    assert logic.imply_op(N,P) == P
+    assert logic.imply_op(Z,P) == P
+    assert logic.imply_op(P,P) == P
+
+def test_rmingle3():
+    logic = RM3()
+    assert logic.imply_op(N,N) == P
+    assert logic.imply_op(Z,N) == N
+    assert logic.imply_op(P,N) == N
+    assert logic.imply_op(N,Z) == P
+    assert logic.imply_op(Z,Z) == Z
+    assert logic.imply_op(P,Z) == N
+    assert logic.imply_op(N,P) == P
+    assert logic.imply_op(Z,P) == P
+    assert logic.imply_op(P,P) == P
+
+def test_paraconsistance():
+    logic = BI3()
+    print(type(logic).__mro__)
+    print(type(logic).imply_op)
+    assert logic.and_op(N,N) == N
+    assert logic.and_op(N,Z) == N
+    assert logic.and_op(N,P) == N
+    assert logic.and_op(Z,N) == N
+    assert logic.and_op(Z,Z) == N
+    assert logic.and_op(Z,P) == Z
+    assert logic.and_op(P,N) == N
+    assert logic.and_op(P,Z) == Z
+    assert logic.and_op(P,P) == P
+
+    assert logic.or_op(N,N) == N
+    assert logic.or_op(N,Z) == Z
+    assert logic.or_op(N,P) == P
+    assert logic.or_op(Z,N) == Z
+    assert logic.or_op(Z,Z) == P
+    assert logic.or_op(Z,P) == P
+    assert logic.or_op(P,N) == P
+    assert logic.or_op(P,Z) == P
+    assert logic.or_op(P,P) == P
+
+    assert logic.imply_op(N,N) == P
+    assert logic.imply_op(Z,N) == Z
+    assert logic.imply_op(P,N) == N
+    assert logic.imply_op(N,Z) == Z
+    assert logic.imply_op(Z,Z) == Z
+    assert logic.imply_op(P,Z) == Z
+    assert logic.imply_op(N,P) == P
+    assert logic.imply_op(Z,P) == Z
+    assert logic.imply_op(P,P) == P

tritlib-0.1.0/tests/test_logic_kleene.py

@@ -0,0 +1,21 @@
+from tritlib.trit import Z, N, P
+
+def test_and():
+    assert (P & P) == P
+    assert (P & Z) == Z
+    assert (P & N) == N
+    assert (Z & Z) == Z
+    assert (Z & N) == N
+
+def test_or():
+    assert (N | N) == N
+    assert (N | Z) == Z
+    assert (N | P) == P
+    assert (Z | Z) == Z
+    assert (Z | P) == P
+
+def test_not():
+    assert ~P == N
+    assert ~Z == Z
+    assert ~N == P
+

tritlib-0.1.0/tests/test_trit.py

@@ -0,0 +1,73 @@
+from tritlib.trit import Trit, N, P, Z
+import pytest
+def test_tritP():
+    t = Trit(1)
+    assert str(t) == "+"
+    assert t == P
+    assert repr(t) == "Trit(1)"
+
+def test_tritN():
+    t = Trit(-1)
+    assert str(t) == "-"
+    assert t == N
+    assert repr(t) == "Trit(-1)"
+
+def test_tritZ():
+    t = Trit(0)
+    assert str(t) == "0"
+    assert t == Z
+    assert repr(t) == "Trit(0)"
+
+def test_trit_invalid():
+    with pytest.raises(ValueError):
+        Trit(2)
+    with pytest.raises(ValueError):
+        Trit(-3)
+
+
+def test_hash():
+    assert hash(Trit(1)) == hash(P)
+    assert hash(Trit(0)) == hash(Z)
+    assert hash(Trit(-1)) == hash(N)
+
+def test_immutable():
+    t = Trit(0)
+    with pytest.raises(AttributeError):
+        t._value = -1
+
+def test_negation():
+    assert -P == N
+    assert -N == P
+    assert -Z == Z
+
+def test_multiplication():
+    assert P * P == P
+    assert P * N == N
+    assert N * N == P
+    assert Z * P == Z
+    assert Z * Z == Z
+
+def test_half_add():
+    # Pas de retenue
+    s, c = P.half_add(N)
+    assert s == Z
+    assert c == Z
+
+    # Retenue négative
+    s, c = N.half_add(N)
+    assert s == P
+    assert c == N
+
+    # Zéro neutre
+    s, c = P.half_add(Z)
+    assert s == P
+    assert c == Z
+
+def full_add():
+    # sans retenue
+    s, c = P.full_add(N, Z)
+    assert s == Z and c == Z
+
+    # avec retenue qui propage
+    s, c = P.full_add(P, P)
+    assert s == Z and c == P

tritlib-0.1.0/tests/test_trits.py

@@ -0,0 +1,100 @@
+from tritlib.trits import Trits
+import pytest
+
+def test_trits_init():
+    assert Trits(0) == Trits.from_str("0")
+    assert int(Trits(5)) == 5
+    assert int(Trits(-5)) == -5
+    assert int(Trits(42)) == 42
+
+def test_trits_init_from_str():
+    assert Trits(-1) == Trits.from_str("-")
+    assert Trits(1) == Trits.from_str("+")
+    assert Trits(0) == Trits.from_str("0")
+
+    assert Trits(2) == Trits.from_str("+-")
+    assert Trits(3) == Trits.from_str("+0")
+    assert Trits(5) == Trits.from_str("+--")
+    assert Trits(-2) == Trits.from_str("-+")
+    assert Trits(-3) == Trits.from_str("-0")
+    assert Trits(-5) == Trits.from_str("-++")
+
+    assert Trits(5) == Trits("+--")
+
+def test_trits_to_str():
+    assert str(Trits(-1)) == "-"
+    assert str(Trits(1)) == "+"
+    assert str(Trits(0)) == "0"
+
+    assert str(Trits(2)) == "+-"
+    assert str(Trits(3)) == "+0"
+    assert str(Trits(5)) == "+--"
+    assert str(Trits(-2)) == "-+"
+    assert str(Trits(-3)) == "-0"
+    assert str(Trits(-5)) == "-++"
+
+def tests_trits_len():
+    assert len(Trits(-1)) == 1
+    assert len(Trits(0)) == 1
+    assert len(Trits(1)) == 1
+    assert len(Trits(-2)) == 2
+    assert len(Trits(-5)) == 3
+    assert len(Trits(5)) == 3
+
+
+def test_trits_add():
+    for i in range(-10,10):
+        for j in range(-10, 10):
+            assert int(Trits(i) + Trits(j)) == i+j
+
+def test_trits_sub():
+    for i in range(-10,10):
+        for j in range(-10, 10):
+            assert int(Trits(i) - Trits(j)) == i-j
+
+def test_trits_mul():
+    for i in range(-100,10):
+        for j in range(-10, 100):
+            assert int(Trits(i) * Trits(j)) == i*j
+
+def test_trits_lt():
+    assert Trits(-1) < Trits(0) < Trits(1)
+    for i in range(-10,10):
+        for j in range(i+1, i+11):
+            assert Trits(i) < Trits(j)
+
+def test_trits_le():
+    assert Trits(42) <= Trits(42)
+    assert Trits(0) <= Trits(20)
+    assert Trits(-19) <= Trits(14)
+    
+def test_trits_gt():
+    assert Trits(1) > Trits(0) > Trits(-1)
+    for i in range(-10,10):
+        for j in range(i-1, i-11):
+            assert Trits(i) > Trits(j)
+
+def test_trits_ge():
+    assert Trits(42) >= Trits(42)
+    assert Trits(20) >= Trits(0)
+    assert Trits(-13) >= Trits(-20)
+
+
+def test_divmod():
+    q, r = divmod(Trits(13), Trits(4))
+    assert int(q) * 4 + int(r) == 13
+    q, r = divmod(Trits(7), Trits(4))
+    assert int(q) == 2 and int(r) == -1
+    q, r = divmod(Trits(-7), Trits(4))
+    assert int(q) * 4 + int(r) == -7
+
+    q, r = divmod(Trits(0), Trits(5))
+    assert int(q) == 0 and int(r) == 0
+
+    with pytest.raises(ZeroDivisionError):
+        divmod(Trits(4),Trits(0))
+
+    q, r = divmod(Trits(5), Trits(15))
+    assert int(q) == 0 and int(r) == 5
+    q, r = divmod(Trits(14), Trits(15))
+    assert int(q) == 1 and int(r) == -1

tritlib-0.1.0/tests/test_tryte.py

@@ -0,0 +1,119 @@
+from tritlib.trits import Trits
+from tritlib.tryte import Tryte
+from tritlib.trit import Z,N,P
+import pytest
+
+def test_tryte():
+    a = Tryte(0, width = 6) 
+    assert a.trits == [Z]*6
+    b = Tryte(2, width = 6)
+    assert b.trits == [N, P] + [Z] * 4
+
+    with pytest.raises(OverflowError):
+        Tryte(-400, width=6)
+    with pytest.raises(OverflowError):
+        Tryte(400, width=6)
+
+    assert Tryte(42, width=6) == Tryte("+---0",6)
+
+def test_tryte_lt():
+    assert Tryte(42, width=6) < Tryte(45, width=6)
+    assert Tryte(-19, width=6) < Tryte(45, width=6)
+    assert Tryte(-42, width=6) < Tryte(-14, width=6)
+    assert Tryte(45, width=6) > Tryte(-42, width=6)
+    assert Tryte(45, width=6) > Tryte(42, width=6)
+    assert Tryte(-15, width=6) > Tryte(-42, width=6)
+    assert Tryte(-42, width=6) <= Tryte(-42, width=6)
+    assert Tryte(42, width=6) >= Tryte(42, width=6)
+
+def test_tryte_width():
+    assert len(Tryte(42,6)) == 6
+    with pytest.raises(ValueError):
+        _ = Tryte(42,6) > Tryte(42,9)
+    with pytest.raises(ValueError):
+        _ = Tryte(42,6) == Tryte(42,9)
+
+def test_tryte_add():
+    assert Tryte(42,6) == Tryte(31,6) + Tryte(11,6)
+    assert Tryte(300,6) + Tryte(300,6)
+    assert (Tryte(332,6),False) == Tryte(300,6).add_with_carry(Tryte(32,6))
+    assert (Tryte(-364,6),True) == Tryte(300,6).add_with_carry(Tryte(65,6))
+    for i in range(-10,10):
+        for j in range(-10,10):
+            assert Tryte(j,6) + Tryte(i,6) == Tryte(i+j, 6)
+
+def test_tryte_neg():
+    assert Tryte(4,6) == -Tryte(-4,6)
+    assert Tryte(0,6) == -Tryte(0,6)
+    assert Tryte(-10,6) == -Tryte(10,6)
+
+def test_tryte_sub():
+    assert Tryte(6,6) - Tryte(7,6) == Tryte(-1,6)
+    assert Tryte(20,6) - Tryte(4,6) == Tryte(16,6)
+    assert Tryte(10,6) - Tryte(24,6) == Tryte(-14,6)
+    for i in range(-10,10):
+        for j in range(-10,10):
+            assert Tryte(j,6) - Tryte(i,6) == Tryte(j-i, 6)
+
+def test_tryte_mul():
+    for i in range(-10,10):
+        for j in range(-10,10):
+            assert Tryte(j,6) * Tryte(i,6) == Tryte(i*j, 6)
+
+def test_tryte_to_str():
+    assert str(Tryte(-1,6)) == "00000-"
+    assert str(Tryte(1,6)) == "00000+"
+    assert str(Tryte(0,6)) == "000000"
+    assert str(Tryte(2,6)) == "0000+-"
+    assert str(Tryte(3,6)) == "0000+0"
+    assert str(Tryte(5,6)) == "000+--"
+    assert str(Tryte(-2,6)) == "0000-+"
+    assert str(Tryte(-3,6)) == "0000-0"
+    assert str(Tryte(-5,6)) == "000-++"
+
+def test_tryte_to_trits():
+    for i in range(-15,15):
+        assert Tryte(i,6).to_trits() == Trits(i)
+
+
+def test_le_trits():
+    assert Tryte(-1,6)._le_trits == [N]
+    assert Tryte(2,6)._le_trits == [P,N]
+    assert Tryte(5,6)._le_trits == [P,N,N]
+    assert Tryte(5,9)._le_trits == [P,N,N]
+    assert Tryte(-5,6)._le_trits == [N,P,P]
+    assert Tryte(-5,9)._le_trits == [N,P,P]
+
+    assert Tryte.from_le_trits([N,P,P],6) == Tryte(-5,6)
+    assert Tryte.from_le_trits([P,N],6) == Tryte(2,6)
+    assert Tryte.from_le_trits([P,N,N],6) == Tryte(5,6)
+    assert Tryte.from_le_trits([N,P,P],9) == Tryte(-5,9)
+
+def test_resize():
+    for j in range(-10,10):
+        for i in range(7,10):
+            a = Tryte(j, 6)
+            assert a.resize(i) == Tryte(j,i)
+
+    le_trits = [N,P,P,Z,P]
+    assert Tryte.from_le_trits(le_trits,6).resize(3) == Tryte.from_le_trits(le_trits[:3],3)
+
+
+def test_divmod():
+    q, r = divmod(Tryte(13,6), Tryte(4,6))
+    assert int(q) * 4 + int(r) == 13
+    q, r = divmod(Tryte(7,6), Tryte(4,6))
+    assert int(q) == 2 and int(r) == -1
+    q, r = divmod(Tryte(-7,6), Tryte(4,6))
+    assert int(q) * 4 + int(r) == -7
+
+    q, r = divmod(Tryte(0,6), Tryte(5,6))
+    assert int(q) == 0 and int(r) == 0
+
+    with pytest.raises(ZeroDivisionError):
+        divmod(Tryte(4,6),Tryte(0,6))
+
+    q, r = divmod(Tryte(5,6), Tryte(15,6))
+    assert int(q) == 0 and int(r) == 5
+    q, r = divmod(Tryte(14,6), Tryte(15,6))
+    assert int(q) == 1 and int(r) == -1