valuebridge-tdfloat 1.0.0__py3-none-any.whl

valuebridge/tdfloat/__init__.py

@@ -0,0 +1,64 @@
+"""
+tdfloat — Triadic Dot Float
+============================
+A floating-point library where every number is a single Python integer
+on the half-step rational line.
+
+The "." is the info_bit (from encoding_any_symbol.v):
+  position = 2 * rank + info_bit
+  info_bit = 0  →  integer axis   (no dot)
+  info_bit = 1  →  half-step axis (has dot)
+
+All arithmetic is exact rational arithmetic.
+No IEEE 754 rounding. No transcendentals. No approximation.
+
+Quick start
+-----------
+    from valuebridge.tdfloat import td, frac, TDFloat
+
+    a = td('0.1')
+    b = td('0.2')
+    c = td('0.3')
+    assert (a + b) + c == a + (b + c)   # always True
+
+    print(TDFloat.PI)    # 22/7  (exact definition of π)
+    print(TDFloat.E)     # 19/7
+    print(TDFloat.PHI)   # 3/2   (the golden ratio = the half-step)
+
+    from valuebridge.tdfloat.math import circle_area, circle_circumference
+    r7 = td(7)
+    print(circle_circumference(r7))   # 44  (exact integer!)
+    print(circle_area(r7))            # 154 (exact integer!)
+
+Constants
+---------
+All constants are exact rationals:
+  π = 22/7,  τ = 44/7,  e = 19/7,  φ = 3/2,  √2 = 7/5,  ½ = 1/2
+"""
+
+from .tdfloat import TDFloat, td, frac, divmod_td
+from . import math
+from . import constants
+
+# Expose constants at package level
+PI    = TDFloat.PI
+TAU   = TDFloat.TAU
+E     = TDFloat.E
+PHI   = TDFloat.PHI
+SQRT2 = TDFloat.SQRT2
+SQRT3 = TDFloat.SQRT3
+HALF  = TDFloat.HALF
+ZERO  = TDFloat.ZERO
+ONE   = TDFloat.ONE
+TWO   = TDFloat.TWO
+NAN   = TDFloat.NAN
+INF   = TDFloat.INF
+
+__version__ = '1.0.0'
+__author__  = 'Tushar Dadlani'
+__all__ = [
+    'TDFloat', 'td', 'frac', 'divmod_td',
+    'PI', 'TAU', 'E', 'PHI', 'SQRT2', 'SQRT3', 'HALF',
+    'ZERO', 'ONE', 'TWO', 'NAN', 'INF',
+    'math', 'constants',
+]

valuebridge/tdfloat/_arithmetic.py

@@ -0,0 +1,258 @@
+"""
+tdfloat._arithmetic
+===================
+Exact rational arithmetic on encoded half-step integers.
+
+Every operation goes: encoded → (p,q) → exact integer arithmetic → encoded.
+No Python float is ever used.
+"""
+
+from ._encoding import (
+    _NAN, _PINF, _NINF, _SPECIALS,
+    to_rational, from_rational,
+)
+
+# Try to use Rust-accelerated versions
+try:
+    from tdfloat_core import td_gcd, td_tddiv
+    _RUST_ARITHMETIC = True
+except ImportError:
+    _RUST_ARITHMETIC = False
+    td_tddiv = None
+
+def _sign_of(encoded: int) -> int:
+    return 1 if encoded < 0 and encoded not in _SPECIALS else 0
+
+def _gcd(a: int, b: int) -> int:
+    if _RUST_ARITHMETIC:
+        # Use Rust GCD for unsigned integers only
+        try:
+            return td_gcd(a, b)
+        except (OverflowError, ValueError):
+            # Fall back to Python if Rust can't handle it
+            while b: a, b = b, a % b
+            return a
+    while b: a, b = b, a % b
+    return a
+
+def _simplify(p: int, q: int) -> tuple:
+    # Use Python _simplify to avoid overflow issues with large numbers
+    # (Python uses arbitrary-precision integers)
+    if q < 0: p, q = -p, -q
+    g = _gcd(abs(p), q) if q else 1
+    return p // g, q // g
+
+def add(a: int, b: int) -> int:
+    if _NAN in (a, b): return _NAN
+    if a == _PINF: return _NAN if b == _NINF else _PINF
+    if a == _NINF: return _NAN if b == _PINF else _NINF
+    if b in (_PINF, _NINF): return b
+    na, da = to_rational(a)
+    nb, db = to_rational(b)
+    p, q = _simplify(na * db + nb * da, da * db)
+    return from_rational(p, q)
+
+def sub(a: int, b: int) -> int:
+    return add(a, neg(b))
+
+def neg(a: int) -> int:
+    if a == _NAN:  return _NAN
+    if a == _PINF: return _NINF
+    if a == _NINF: return _PINF
+    return -a   # sign lives in Python int sign
+
+def mul(a: int, b: int) -> int:
+    if _NAN in (a, b): return _NAN
+    if a in (_PINF, _NINF) or b in (_PINF, _NINF):
+        sa = 1 if (a == _NINF or (a < 0 and a not in _SPECIALS)) else 0
+        sb = 1 if (b == _NINF or (b < 0 and b not in _SPECIALS)) else 0
+        return _NINF if (sa ^ sb) else _PINF
+    na, da = to_rational(a)
+    nb, db = to_rational(b)
+    p, q = _simplify(na * nb, da * db)
+    return from_rational(p, q)
+
+def div(a: int, b: int) -> int:
+    """Division using tddiv internally.
+    Returns the full rational result: quotient + remainder/denominator as encoded value.
+    """
+    if _NAN in (a, b): return _NAN
+    nb, db = to_rational(b)
+    if nb == 0:
+        # division by zero: return signed infinity based on sign of a
+        na, da = to_rational(a)
+        if na == 0: return _NAN   # 0/0 = nan
+        return _NINF if na < 0 else _PINF
+
+    # Use tddiv internally for exact three-term semantics
+    quot_e, rem_e, den_e = divmod_td(a, b)
+
+    # Reconstruct: result = quotient + remainder/denominator as a single encoded value
+    if rem_e == 0:
+        return quot_e
+
+    # Extract the rational components
+    # Note: divmod_td returns integers encoded as rationals with denominator 1
+    p_q, q_q = to_rational(quot_e)  # quotient as integer
+    p_r, q_r = to_rational(rem_e)  # remainder as integer
+    p_d, q_d = to_rational(den_e)  # denominator as integer
+
+    # Compute: result = quotient + remainder/denominator
+    #                = (quotient * denominator + remainder) / denominator
+    # Since q_q = q_r = q_d = 1 (they're all integers):
+    num = p_q * p_d + p_r
+    den = p_d
+    p, q = _simplify(num, den)
+    return from_rational(p, q)
+
+def floordiv(a: int, b: int) -> int:
+    """Floor division using tddiv internally.
+    Returns only the quotient part (whole number).
+    """
+    if _NAN in (a, b) or b in (_PINF, _NINF): return _NAN
+    nb, db = to_rational(b)
+    if nb == 0: return _NAN
+
+    # Use tddiv to get quotient directly
+    quot_e, rem_e, den_e = divmod_td(a, b)
+    return quot_e
+
+def mod(a: int, b: int) -> int:
+    """Modulo using tddiv internally.
+    Computes: a mod b = a - b * floor(a/b)
+    Returns the remainder from the division.
+    """
+    if _NAN in (a, b) or b in (_PINF, _NINF): return _NAN
+    nb, db = to_rational(b)
+    if nb == 0: return _NAN
+
+    # Use tddiv to get quotient directly
+    quot_e, rem_e, den_e = divmod_td(a, b)
+
+    # Compute: a - b * quotient
+    return sub(a, mul(b, quot_e))
+
+def divmod_td(a: int, b: int) -> tuple:
+    """Three-term division: returns (quotient, remainder, denominator).
+
+    Semantics: a/b = quotient + remainder/denominator
+    All three terms are encoded as half-step integers.
+
+    Args:
+        a, b: encoded half-step integers
+
+    Returns:
+        (quotient_enc, remainder_enc, denominator_enc) where each is encoded
+    """
+    if _NAN in (a, b): return (_NAN, _NAN, _NAN)
+    if b in (_PINF, _NINF) or b == 0: return (_NAN, _NAN, _NAN)
+    if a == 0: return (0, 0, 1)  # 0/b = (0, 0, 1)
+
+    if _RUST_ARITHMETIC and td_tddiv is not None:
+        return td_tddiv(a, b)
+
+    # Pure Python fallback (less efficient but correct)
+    na, da = to_rational(a)
+    nb, db = to_rational(b)
+
+    # a/b = (na/da) / (nb/db) = (na*db) / (da*nb)
+    p = na * db
+    q = da * nb
+
+    # Reduce via GCD
+    from math import gcd as py_gcd
+    g = py_gcd(abs(p), abs(q))
+    p, q = p // g, q // g
+
+    # Ensure q is positive
+    if q < 0:
+        p, q = -p, -q
+
+    # Get quotient and remainder
+    quot = p // q
+    rem = p % q
+
+    # Encode all three terms
+    sign_q = quot < 0
+    quot_enc = from_rational(abs(quot), 1) if quot != 0 else 0
+    if sign_q and quot != 0:
+        quot_enc = -quot_enc if quot_enc >= 0 else quot_enc
+
+    sign_r = rem < 0
+    rem_enc = from_rational(abs(rem), 1) if rem != 0 else 0
+    if sign_r and rem != 0:
+        rem_enc = -rem_enc if rem_enc >= 0 else rem_enc
+
+    den_enc = from_rational(q, 1)
+
+    return (quot_enc, rem_enc, den_enc)
+
+def eq(a: int, b: int) -> bool:
+    if a in _SPECIALS or b in _SPECIALS:
+        return a == b and a != _NAN
+    na, da = to_rational(a)
+    nb, db = to_rational(b)
+    return na * db == nb * da
+
+def lt(a: int, b: int) -> bool:
+    if _NAN in (a, b): return False
+    if a == _NINF: return b != _NINF
+    if b == _PINF: return a != _PINF
+    if a == _PINF or b == _NINF: return False
+    na, da = to_rational(a)
+    nb, db = to_rational(b)
+    # na/da < nb/db  iff  na*db < nb*da  (both denominators positive)
+    return na * db < nb * da
+
+def abs_val(a: int) -> int:
+    if a in _SPECIALS: return a
+    return -a if a < 0 else a
+
+def pow_int(a: int, n: int) -> int:
+    """Integer power via repeated squaring."""
+    if n < 0:
+        return div(from_rational(1, 1), pow_int(a, -n))
+    result = from_rational(1, 1)
+    base   = a
+    while n:
+        if n & 1: result = mul(result, base)
+        base = mul(base, base)
+        n >>= 1
+    return result
+
+def isqrt_rational(p: int, q: int) -> tuple:
+    """
+    Integer square root of p/q as a rational.
+    Returns (rp, rq) such that (rp/rq)^2 ≈ p/q.
+    Uses Newton's method on integers.
+    """
+    if p < 0: return (0, 0)  # NaN
+    if p == 0: return (0, 1)
+
+    # sqrt(p/q) = sqrt(p*q) / q
+    # We compute isqrt(p*q) then divide by q
+    target = p * q
+    # Scale up for precision: sqrt(target * 10^(2k)) = sqrt(target) * 10^k
+    PREC = 80  # decimal digits of precision
+    scale = 10 ** (PREC * 2)
+    n = target * scale
+    x = 1 << (n.bit_length() // 2 + 1)
+    while True:
+        x1 = (x + n // x) >> 1
+        if x1 >= x: break
+        x = x1
+    # result = x / (sqrt(scale) * q) = x / (10^PREC * q)
+    rp, rq = _simplify(x, (10 ** PREC) * q)
+    return rp, rq
+
+def sqrt(a: int) -> int:
+    """Square root via exact rational Newton's method."""
+    from ._encoding import _NAN, _PINF, _NINF
+    if a == _NAN: return _NAN
+    if a == _NINF: return _NAN
+    if a == _PINF: return _PINF
+    na, da = to_rational(a)
+    if na < 0: return _NAN
+    if na == 0: return from_rational(0, 1)
+    rp, rq = isqrt_rational(na, da)
+    return from_rational(rp, rq)

valuebridge/tdfloat/_encoding.py

@@ -0,0 +1,161 @@
+"""
+tdfloat._encoding
+=================
+The half-step symbol encoding from encoding_any_symbol.v
+
+  position = 2 * rank + info_bit      encode_symbol
+  rank     = position >> 1            decode_rank
+  info_bit = position & 1             decode_info
+
+The "." is the info_bit:
+  info_bit = 0  →  integer axis   (even position, no dot)
+  info_bit = 1  →  half-step axis (odd  position, has dot)
+"""
+
+# ── Layout ────────────────────────────────────────────────────────────
+MAX_DOT_POS   = 77          # maximum fractional decimal places
+DOT_POSITIONS = MAX_DOT_POS + 1   # 78 distinct scale values (0..77)
+
+# Sentinel values for special numbers (outside the half-step line)
+_NAN  = -1
+_PINF = -2
+_NINF = -3
+_SPECIALS = (_NAN, _PINF, _NINF)
+
+
+# ── The three primitives from encoding_any_symbol.v ──────────────────
+
+def encode_symbol(rank: int, info_bit: int) -> int:
+    """position = 2 * rank + info_bit"""
+    return 2 * rank + (info_bit & 1)
+
+def decode_rank(position: int) -> int:
+    """rank = position // 2"""
+    return position >> 1
+
+def decode_info(position: int) -> int:
+    """info_bit = position mod 2  (0=integer axis, 1=half-step axis)"""
+    return position & 1
+
+
+# ── Pack / unpack a float as (sign, abs_digits, dot_pos) ─────────────
+
+def pack(sign: int, abs_digits: int, dot_pos: int) -> int:
+    """
+    Encode (sign, digits, dot_pos) as a single integer on the half-step line.
+    sign=0 positive, sign=1 negative.
+    dot_pos=0 means integer (no dot, info_bit=0).
+    dot_pos>0 means fractional (dot present, info_bit=1).
+    """
+    assert 0 <= dot_pos <= MAX_DOT_POS, f"dot_pos {dot_pos} out of range"
+    info_bit = 1 if dot_pos > 0 else 0
+    rank     = abs_digits * DOT_POSITIONS + dot_pos
+    position = encode_symbol(rank, info_bit)
+    return -position if sign else position
+
+def unpack(encoded: int) -> tuple:
+    """Return (sign, abs_digits, dot_pos). sign=0 positive, 1 negative."""
+    if encoded < 0:
+        sign, position = 1, -encoded
+    else:
+        sign, position = 0, encoded
+    rank               = decode_rank(position)
+    dot_pos            = rank % DOT_POSITIONS
+    abs_digits         = rank // DOT_POSITIONS
+    return sign, abs_digits, dot_pos
+
+
+# ── Exact rational ↔ encoded int ─────────────────────────────────────
+
+def to_rational(encoded: int) -> tuple:
+    """Return (numerator, denominator). numerator may be negative."""
+    if encoded in _SPECIALS:
+        return (0, 0)
+    sign, digits, dot_pos = unpack(encoded)
+    denom = 10 ** dot_pos
+    return (-digits if sign else digits), denom
+
+def from_rational(num: int, den: int) -> int:
+    """Build encoded int from exact integer ratio num/den.
+    Uses pure Python with arbitrary-precision integers to handle all rationals.
+    """
+    if den == 0:
+        return _NAN
+    if num == 0:
+        return pack(0, 0, 0)
+
+    sign = 1 if num < 0 else 0
+    num  = abs(num)
+
+    # Find shortest exact decimal representation up to MAX_DOT_POS
+    for dot_pos in range(MAX_DOT_POS + 1):
+        scaled = num * (10 ** dot_pos)
+        if scaled % den == 0:
+            return pack(sign, scaled // den, dot_pos)
+
+    # Inexact — round to MAX_DOT_POS places
+    scaled = num * (10 ** MAX_DOT_POS)
+    digits = (scaled + den // 2) // den
+    return pack(sign, digits, MAX_DOT_POS)
+
+
+# ── String ↔ encoded int ──────────────────────────────────────────────
+
+def from_str(s: str) -> int:
+    """Parse decimal string to encoded int. No Python float used."""
+    s = s.strip().lower()
+    for alias, val in (('inf',_PINF),('+inf',_PINF),('-inf',_NINF),('nan',_NAN)):
+        if s == alias: return val
+
+    sign = 0
+    if s.startswith('-'):  sign = 1; s = s[1:]
+    elif s.startswith('+'): s = s[1:]
+
+    exp10 = 0
+    if 'e' in s:
+        s, ep = s.split('e', 1); exp10 = int(ep)
+
+    has_dot = '.' in s
+    if has_dot:
+        ipart, fpart = s.split('.', 1)
+    else:
+        ipart, fpart = s, ''
+
+    ipart  = ipart or '0'
+    digits = int(ipart + fpart) if (ipart + fpart) else 0
+
+    raw_dot = len(fpart) - exp10
+
+    if raw_dot < 0:
+        digits  *= 10 ** (-raw_dot)
+        dot_pos  = 0
+    elif raw_dot > MAX_DOT_POS:
+        excess   = raw_dot - MAX_DOT_POS
+        digits   = (digits + 10**(excess-1)*5) // (10 ** excess)
+        dot_pos  = MAX_DOT_POS
+    else:
+        dot_pos = raw_dot
+
+    # Strip trailing fractional zeros, but preserve the dot presence
+    min_dot = 1 if has_dot or exp10 < 0 else 0
+    while dot_pos > min_dot and digits % 10 == 0:
+        digits  //= 10
+        dot_pos  -= 1
+
+    return pack(sign, digits, dot_pos)
+
+def to_str(encoded: int, max_digits: int = 40) -> str:
+    """Convert encoded int to decimal string."""
+    if encoded == _NAN:  return 'nan'
+    if encoded == _PINF: return 'inf'
+    if encoded == _NINF: return '-inf'
+    sign, digits, dot_pos = unpack(encoded)
+    s = '-' if sign else ''
+    ds = str(digits)
+    if dot_pos == 0:
+        return s + ds + '.0' if False else s + ds  # integers: no trailing .0
+    if len(ds) <= dot_pos:
+        ds = '0' * (dot_pos - len(ds) + 1) + ds
+    int_part  = ds[:-dot_pos] or '0'
+    frac_part = ds[-dot_pos:].rstrip('0') or '0'
+    return s + int_part + '.' + frac_part

valuebridge/tdfloat/constants.py

@@ -0,0 +1,112 @@
+"""
+tdfloat.constants
+=================
+Every mathematical constant defined as an exact rational p/q.
+
+In the tdfloat universe there are no transcendentals.
+Every constant occupies a unique, permanent position on the half-step line.
+The "." is the info_bit; its presence places a constant on the half-step axis.
+
+Constant definitions
+--------------------
+π  = 22/7    circumference/diameter in the 45°-rotated Gaussian plane
+τ  = 44/7    full rotation (2π)
+e  = 19/7    natural growth base in 3-step algebra
+ln2 = 2/3   half-life constant
+φ  = 3/2    golden ratio = the fundamental half-step
+√2 = 7/5    diagonal of unit square (first CF convergent)
+√3 = 7/4    equilateral triangle height ratio
+√5 = 9/4    from the golden ratio construction
+½  = 1/2    the half-step atom itself
+"""
+
+from __future__ import annotations
+from ._encoding import from_rational, _NAN
+
+def _gcd(a, b):
+    while b: a, b = b, a % b
+    return a
+
+def _s(p, q):
+    if q < 0: p, q = -p, -q
+    g = _gcd(abs(p), q)
+    return p // g, q // g
+
+
+class Constant:
+    """
+    A named rational constant.
+    Stores (p, q) as the canonical fraction and provides
+    exact arithmetic without going through decimal encoding.
+    """
+    __slots__ = ('name', 'p', 'q', '_encoded')
+
+    def __init__(self, name: str, p: int, q: int):
+        self.name = name
+        self.p, self.q = _s(p, q)
+        self._encoded = from_rational(self.p, self.q)
+
+    def encoded(self) -> int:
+        return self._encoded
+
+    def as_tdf(self):
+        """Return this constant as a TDFloat."""
+        from .tdfloat import TDFloat
+        return TDFloat(self._encoded)
+
+    def __repr__(self) -> str:
+        from ._encoding import to_str
+        return f'{self.name} = {self.p}/{self.q} ({to_str(self._encoded)!r})'
+
+    def __float__(self) -> float:
+        return self.p / self.q
+
+    # Exact arithmetic returning (p, q) tuples
+    def __mul__(self, other: 'Constant') -> 'Constant':
+        p, q = _s(self.p * other.p, self.q * other.q)
+        return Constant(f'{self.name}*{other.name}', p, q)
+
+    def __add__(self, other: 'Constant') -> 'Constant':
+        p, q = _s(self.p * other.q + other.p * self.q, self.q * other.q)
+        return Constant(f'{self.name}+{other.name}', p, q)
+
+    def __sub__(self, other: 'Constant') -> 'Constant':
+        p, q = _s(self.p * other.q - other.p * self.q, self.q * other.q)
+        return Constant(f'{self.name}-{other.name}', p, q)
+
+    def __truediv__(self, other: 'Constant') -> 'Constant':
+        p, q = _s(self.p * other.q, self.q * other.p)
+        return Constant(f'{self.name}/{other.name}', p, q)
+
+    def __neg__(self) -> 'Constant':
+        return Constant(f'-{self.name}', -self.p, self.q)
+
+
+# ── The registry ──────────────────────────────────────────────────────
+
+PI    = Constant('π',    22,  7)   # circumference / diameter
+TAU   = Constant('τ',    44,  7)   # 2π
+E     = Constant('e',    19,  7)   # natural base
+LN2   = Constant('ln2',   2,  3)   # log(2)
+LN10  = Constant('ln10',  7,  3)   # log(10)
+LOG2E = Constant('log2e', 3,  2)   # log₂(e) = 1/ln2 = φ
+SQRT2 = Constant('√2',    7,  5)   # √2
+SQRT3 = Constant('√3',    7,  4)   # √3
+SQRT5 = Constant('√5',    9,  4)   # √5
+PHI   = Constant('φ',     3,  2)   # golden ratio = the half-step
+SIN45 = Constant('sin45', 1,  2)   # sin(45°) in identity-axis geometry
+COS45 = Constant('cos45', 1,  2)
+SIN30 = Constant('sin30', 1,  2)
+COS30 = Constant('cos30', 7,  8)   # √3/2
+SIN60 = Constant('sin60', 7,  8)
+COS60 = Constant('cos60', 1,  2)
+HALF  = Constant('½',     1,  2)   # the fundamental half-step atom
+ALPHA = Constant('α',     1, 137)  # fine structure constant
+
+ALL: dict[str, Constant] = {
+    'pi': PI, 'tau': TAU, 'e': E, 'ln2': LN2, 'ln10': LN10,
+    'log2e': LOG2E, 'sqrt2': SQRT2, 'sqrt3': SQRT3, 'sqrt5': SQRT5,
+    'phi': PHI, 'sin45': SIN45, 'cos45': COS45, 'sin30': SIN30,
+    'cos30': COS30, 'sin60': SIN60, 'cos60': COS60,
+    'half': HALF, 'alpha': ALPHA,
+}