daatypes 0.1.0__py3-none-any.whl

daatypes/__init__.py

@@ -0,0 +1,75 @@
+# hello! welcome to daatypes where i propose my own datatypes i find useful in my work
+
+# unsigned integer
+# represents the natural numbers starting from zero
+# can also do saturating and modular arithmetic
+from .uint import UInt 
+
+# 2's complement signed integer
+# represents the integers
+# can also do saturating and modular arithmetic
+from .int import Int 
+
+# unsigned binary fixed point number format
+# represents the non-negative binary rationals
+# can also do saturating and modular arithmetic
+from .uqint import UQInt
+
+# signed binary fixed point number format
+# represents the binary rationals
+# can also do saturating and modular arithmetic
+from .qint import QInt 
+
+# fixed point numbers
+from .fixed import Fixed
+
+# scientific notation in arbitrary radix
+# represents the rational numbers
+from .float import Float, ieee_binary, ieee_decimal, f16, f32, f64, f128, f256, d32, d64, d128
+
+# a composed datatype
+# two arrays of int primes[] and int exponents[]
+# represents the rationals 
+# conducive to slow additive but fast multiplicative arithmetic
+from .monzo import Monzo 
+
+# (simple)? continued fraction
+from .cf import CF, SCF
+
+# a composed datatype
+# an ordered pair of (any lower, any upper)
+# represents a closed-closed interval on the real number line
+# conducive to fast tolerance-aware arithmetic
+from .interval import Interval 
+
+# a composed datatype
+# an ordered pair of (centre, +ve radius)
+# represents a ball in an R-vector space
+# conducive to tolerance-aware arithmetic with accurate tolerance
+from .ball import Ball 
+
+# vectors of real numbers ------------------------------------------------------
+
+from .vector import Vector
+
+# represents the real numbers
+from .real import Real
+
+# a composed datatype
+# represents the complexes in cartesian form
+from .comp import Comp
+
+# a composed datatype
+# represents the quaternions in cartesian form
+from .quat import Quat
+
+# a composed datatype
+# represents the quaternions in cartesian form
+from .octo import Octo
+
+# a composed datatype
+# an ordered pair of (qint magnitude, float angle) where angle is from real axis to imaginary axis
+# represents the complex numbers
+# conducive to slow additive but fast multiplicative arithmetic, and uniform angle precision
+from .polar import Polar
+

daatypes/ball.py

@@ -0,0 +1,22 @@
+from numbers import Number, Real
+import daacorations
+from dataclasses import dataclass, Field
+
+@dataclass
+class Ball(Number):
+    'a composed datatype representing an axially symmetric (i think) p-norm ball in an R-vector space'
+    
+    midpoint: Number
+    radius: Real
+    power: Real
+    
+    def __post_init__(self):
+        if self.radius < 0:
+            raise ValueError(f'{self.radius=} must be non-negative')
+        if self.power < 0:
+            raise ValueError(f'{self.radius=} must be non-negative')
+    
+    __repr__ = daacorations.pretty_repr
+
+class EBall:
+    'a Ball but with p = 2 (euclidean), thus representing a hypersphere'

daatypes/cf.py

@@ -0,0 +1,79 @@
+import math, builtins
+from dataclasses import dataclass
+from numbers import Number, Rational, Integral
+from collections.abc import Sequence, MutableSequence
+from typing import Literal
+from daacorations import pretty_repr
+from fractions import Fraction
+
+@dataclass
+class CF(Number):
+    'a continued fraction'
+    numerators: Sequence
+    denominators: Sequence
+    signum: Literal[-1, 0, +1] = +1
+    numerators_repeat: None | int = None
+    denominators_repeat: None | int = None
+    
+    @property
+    def integral(self) -> Integral:
+        return self.denominators[0]
+    
+    @property
+    def fractional(self) -> Rational:
+        ...
+
+    def __str__(self) -> str:
+        sign = {-1: '-', 0: '', +1: '+'}[self.signum]
+        return f'{sign}({self.denominators[0]} + {" + ".join(f"{n}/{d}"for n, d in zip(self.numerators[1:], self.denominators[1:]))})'
+
+    __repr__ = pretty_repr
+
+def quotrem_nearest_even(n, d):
+    q = round(n / d)
+    return q, n - q * d
+
+class SCF(CF, Sequence):
+    'a simple continued fraction with a Sequence interface'
+    def __init__(self, denominators: Sequence, signum = +1):
+        super().__init__([0, 1], denominators, signum, numerators_repeat = 1)
+    
+    # Sequence methods
+    def __getitem__(self, index: int) -> int:
+        return self.denominators[index]
+    def __len__(self) -> int:
+        return len(self.denominators)
+    
+    @classmethod
+    def from_rational(cls, rational: Rational, round = math.floor) -> SCF:
+        'set round=builtins.round or round=math.ceil for interesting partial denominators'
+        signum = (rational > 0) - (rational < 0)
+        rational = abs(rational)
+        
+        denominators: MutableSequence[int] = list()
+        
+        while True:
+            quotient = round(rational)
+            denominators.append(quotient) 
+            remainder = rational.numerator - quotient * rational.denominator
+            if remainder == 0:
+                break
+            rational = Fraction(rational.denominator, remainder)
+        
+        return cls(denominators, signum)
+    
+    def to_rational(self) -> Rational:
+        if len(self.denominators) == 1:
+            return self.signum * self.denominators[0]
+
+        ac = Fraction(self.denominators[-1], 1)
+
+        for d in reversed(self.denominators[:-1]):
+            ac = d + 1 / ac
+
+        return self.signum * ac
+
+    def __str__(self) -> str:
+        return f'[{self.denominators[0]};{",".join(str(d) for d in self.denominators[1:])}]'
+    
+    __repr__ = pretty_repr

daatypes/comp.py

@@ -0,0 +1,49 @@
+import math
+from numbers import Complex, Real
+from .vector import Vector
+
+class Comp(Vector, Complex):
+    'a complex number. a vector of 2 real numbers'
+    def __init__(self, real, imag):
+        self.real = real
+        self.imag = imag
+        super.__init__((real, imag))
+    
+    @classmethod
+    def from_complex(cls, c: Complex) -> Comp:
+        return cls(c.real, c.imag)
+
+    def norm(self) -> Real:
+        return math.sqrt(self.real * self.real + self.imag * self.imag)
+    
+    def unit(self) -> Real:
+        return type(self)(self.real / self.norm(), self.imag / self.norm())
+    
+    def conjugate(self) -> Comp:
+        return type(self)(self.real, -self.imag)
+    
+    __abs__ = norm
+    
+    def __neg__(self) -> Comp:
+        return type(self)(-self.real, -self.imag)
+    def __pos__(self) -> Comp:
+        return type(self)(+self.real, +self.imag)
+    
+    def __add__(self, other) -> Comp:
+        return type(self)(self.real + other.real, self.imag + other.imag)
+    
+    def __mul__(self, other) -> Comp:
+        return type(self)(self.real*other.real-self.imag*other.imag, self.real*other.imag+self.imag*other.real)
+
+    def __complex__(self) -> complex:
+        return complex(self.real, self.imag)
+            
+    def __eq__(self, other) -> bool:
+        return self.real == other.real and self.imag == other.imag
+                
+    # '__pow__',
+    # '__radd__',
+    # '__rmul__',
+    # '__rpow__',
+    # '__rtruediv__',
+    # '__truediv__',

daatypes/fixed.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+from stringman.unicode import to_subscript
+from numbers import Rational, Integral
+from collections.abc import Sequence, MutableSequence, Iterable
+from typing import Literal
+from dataclasses import dataclass, field
+from itertools import chain, cycle, repeat
+from fractions import Fraction
+import math
+
+@dataclass(kw_only = True)
+class Fixed(Rational):
+    'a rational number with a fixed radix point. could potentially be an n-adic number class some day…'
+    signum: Literal[-1, 0, +1]
+    radix: Integral
+    left: Sequence[Integral] = field(default_factory = tuple)
+    right: Sequence[Integral] = field(default_factory = tuple)
+    left_repeat: None | Integral = None
+    right_repeat: None | Integral = None
+
+    def to_fraction(self) -> Fraction:
+        value = self.signum * sum(chain(
+            (digit * self.radix ** i for i, digit in enumerate(self.left, start = 0)),
+            (digit * self.radix ** -i for i, digit in enumerate(self.right, start = 1))))
+
+    @property
+    def numerator(self) -> Integral:
+        if self.left_repeat is not None:
+            raise ValueError(f'{self} is not a rational number')
+        return 
+    @property
+    def denominator(self) -> Integral:
+        if self.left_repeat is not None:
+            raise ValueError(f'{self} is not a rational number')
+        return 
+                    
+    @property
+    def left_preperiod(self):
+        return self.left if self.left_repeat is None else self.left[:self.left_repeat]
+    @property
+    def right_preperiod(self):
+        return self.right if self.right_repeat is None else self.right[:self.right_repeat]
+    @property
+    def left_repetend(self):
+        return () if self.left_repeat is None else self.left[self.left_repeat:]
+    @property
+    def right_repetend(self):
+        return () if self.right_repeat is None else self.right[self.right_repeat:]
+
+    @property
+    def left_iterable(self) -> Iterable:
+        yield from self.left_preperiod
+        if self.left_repetend: 
+            yield from cycle(self.left_repetend) 
+        else: 
+            yield from repeat(0)
+    @property
+    def right_iterable(self) -> Iterable:
+        yield from self.right_preperiod
+        if self.right_repetend: 
+            yield from cycle(self.right_repetend) 
+        else: 
+            yield from repeat(0)
+    
+    @classmethod
+    def from_integral(cls, integral: Integral, radix: Integral) -> Fixed:
+        if integral == 0:
+            return cls(signum=0, radix=radix)
+        signum = (integral > 0) - (integral < 0)
+        integral = abs(integral)
+        
+        left: MutableSequence[Integral] = list()
+        while integral > 0:
+            integral, index = divmod(integral, radix)
+            left.append(index)
+        
+        return cls(signum=signum, left=left, radix=radix)
+    
+    @classmethod
+    def from_rational(cls, rational: Rational, radix: Integral, right_limit: None | int = None) -> Fixed:
+        if rational == 0:
+            return cls(signum=0, radix=radix)
+        
+        signum = (rational > 0) - (rational < 0)
+        rational = abs(rational)
+        
+        integral, remainder = divmod(rational.numerator, rational.denominator)
+
+        left: MutableSequence[Integral] = list()
+        while integral > 0:
+            integral, index = divmod(integral, radix)
+            left.append(index)
+        
+        right: MutableSequence = list()
+        remainders: dict[int, int] = dict() # remainders[remainder] = index
+        
+        while True:
+            if remainder == 0 or remainder in remainders:
+                break 
+            
+            remainders[remainder] = len(right)
+            
+            digit, remainder = divmod(remainder * radix, rational.denominator)
+            right.append(digit)
+
+            if right_limit is not None and len(right) >= right_limit:
+                break
+        
+        return cls(signum = signum, radix = radix, left=left, right=right, right_repeat = remainders.get(remainder, None))
+    
+    def __pos__(self) -> Fixed:
+        return self
+    def __neg__(self) -> Fixed:
+        return type(self)(signum=-self.signum, radix=self.radix, left=left, right=right, left_repeat=left_repeat, right_repeat=right_repeat)
+    def __abs__(self) -> Fixed:
+        return type(self)(signum=+1, radix=self.radix, left=left, right=right, left_repeat=left_repeat, right_repeat=right_repeat)
+    def __add__(self, other) -> Fixed:
+        ...
+    def __floor__(self) -> Fixed:
+        return type(self)(signum=self.signum, radix=self.radix, left=left, right=right, left_repeat=left_repeat, right_repeat=right_repeat)
+    def __ceil__(self) -> Fixed:
+        return 
+    def __trunc__(self) -> Fixed:
+        return type(self)(signum=self.signum, radix=self.radix, left=left, left_repeat=left_repeat)
+    def __floordiv__(self, other) -> Fixed:
+        return 
+    def __le__(self, other) -> bool:
+        return 
+    def __lt__(self, other) -> bool:
+        return self <= other and not other <= self
+    def __mod__(self, other) -> Fixed:
+        return 
+    def __mul__(self, other) -> Fixed:
+        return 
+    def __pow__(self, other) -> Fixed:
+        return 
+    def __radd__(self) -> Fixed:
+        return 
+    def __rfloordiv__(self) -> Fixed:
+        return 
+    def __rmod__(self) -> Fixed:
+        return 
+    def __rmul__(self) -> Fixed:
+        return 
+    def __round__(self) -> Fixed:
+        return 
+    def __rpow__(self) -> Fixed:
+        return 
+    def __rtruediv__(self) -> Fixed:
+        return 
+    def __truediv__(self) -> Fixed:
+        return 
+    
+    def __float__(self) -> float:
+        if self.left_repeat is not None:
+            return self.signum * math.inf
+        return self.signum * sum(chain(
+            (digit * self.radix ** i for i, digit in enumerate(self.left, start = 0)),
+            (digit * self.radix ** -i for i, digit in enumerate(self.right, start = 1))))
+
+    def __str__(self, 
+                char_set = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+                left_precision: None | int = None, 
+                right_precision: None | int = None
+        ) -> str:
+
+        sign: str = {-1: '−', 0: '', +1: '+'}[self.signum]
+        
+        if left_precision is not None:
+            if self.left_repeat is None:
+                # left terminates
+                left: str = ''.join(char_set[digit] for digit in reversed(self.left_preperiod))
+            else:
+                # left has repeating digits
+                left: str = ...
+        else:
+            repetend: str = ''.join(char_set[digit] for digit in reversed(self.left_repetend)) if len(self.left_repetend) != 0 else '0'
+            preperiod: str = ''.join(char_set[digit] for digit in reversed(self.left_preperiod))
+            left: str = '(' + repetend + ')' + preperiod
+
+        if right_precision is not None:
+            if self.right_repeat is None:
+                # right terminates
+                right: str = ''.join(char_set[digit] for digit in self.right_preperiod)
+            else:
+                # right has repeating digits
+                right: str = ...
+        else:
+            repetend: str = ''.join(char_set[digit] for digit in self.right_repetend) if len(self.right_repetend) != 0 else '0'
+            preperiod: str = ''.join(char_set[digit] for digit in self.right_preperiod)
+            right: str = preperiod + '(' + repetend + ')'
+     
+        return f'{sign}{left}.{right}'
+
+def round_expansion(integral, fractional, radix, tie):
+    'round a positional number'
+    twice = 2 * remainder
+
+    if twice < divisor:
+        # round down/do nothing
+        return integral, fractional_digits, None
+    elif twice == divisor:
+        # a tie. like rounding 0.95 to 1 decimal digit. you have to choose a rule
+        match tie:
+            case 'up': fractional_digits[-1] += 1
+            case 'down': fractional_digits[-1] += 0
+            case 'even': fractional_digits[-1] += fractional_digits[-1] % 2 == 1
+            case 'odd': fractional_digits[-1] += fractional_digits[-1] % 2 == 0
+    elif twice > divisor:
+        fractional_digits[-1] += 1
+    
+    # propagate the addition
+    for i in range(fractional_digit_count - 1, 0, -1):
+        if fractional_digits[i] >= radix:
+            fractional_digits[i] = 0
+            fractional_digits[i - 1] += 1
+    if fractional_digits[0] >= radix:
+        integral += 1
+''' 
+def rational_to_scientific(rational: Rational, precision: int, radix: int = 10, exponent_marker: str = 'e', char_set: str = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ') -> str:
+    'stringify a rational number to scientific format (e.g. 1/3 → +3.(3)e-1)'
+    
+    if rational == 0:
+        return '0' + exponent_marker + '0'
+
+    # normalize significand and exponent so that 1 <= significand < radix
+    sig: Rational = abs(rational)
+    exp: int = 0
+    while not 1 <= sig:
+        sig *= radix
+        exp -= 1
+    while not sig < radix:
+        sig /= radix
+        exp += 1
+
+    # now we just need to convert sig rational to digits, and exponent integer to digits
+    sig_sign = '' if rational == 0 else ('-' if rational < 0 else '+').lstrip('+')
+    sig = rational_to_digits(sig, fractional_precision = precision - 1, radix = radix, char_set = char_set)
+    exp_sign = '' if exp == 0 else ('-' if exp < 0 else '+')
+    exp = integral_to_digits(exp, radix = radix, char_set = char_set).lstrip('+')
+    
+    return sig_sign + sig + exponent_marker + exp_sign + exp
+'''

daatypes/float.py

@@ -0,0 +1,232 @@
+import daacorations, math, builtins
+from numbers import Rational
+from fractions import Fraction
+from dataclasses import dataclass
+def xor(a, b): return (a and b) or (not(a or b))
+
+def fraction_to_radix(numerator: int, denominator: int, *, 
+            radix: int,
+            alphabet: str = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+            fractional_digit_count: int = 99) -> str:
+
+    print(radix, numerator, denominator)
+
+    assert isinstance(numerator, int)
+    assert isinstance(denominator, int)
+
+    positive = xor(numerator >= 0, denominator >= 0)
+    sign = '' if positive else '-'
+    
+    integral, fractional = divmod(abs(numerator), abs(denominator))
+    
+    if integral == 0:
+        integral_str = '0'
+    else:
+        integral_digits: list[str] = []
+        while integral:
+            integral_digits.append(alphabet[integral % radix])
+            integral //= radix
+        integral_str = ''.join(reversed(integral_digits))
+
+    if fractional == 0:
+        return sign + integral_str
+
+    seen: dict[int, int] = dict()
+    fractional_digits: list[str] = list()
+
+    for _ in range(fractional_digit_count):
+        if not fractional:
+            break
+
+        if fractional in seen:
+            # repeating pattern
+            index = seen[fractional]
+            return sign + integral_str + '.' + ''.join(fractional_digits[:index]) + '(' + ''.join(fractional_digits[index:]) + ')'
+
+        seen[fractional] = len(fractional_digits)
+        
+        fractional *= radix
+        digit = fractional // denominator
+        fractional %= denominator
+        fractional_digits.append(alphabet[digit])
+    else:
+        return sign + integral_str + '.' + ''.join(fractional_digits) + '…'
+    
+    return sign + integral_str + '.' + ''.join(fractional_digits)
+
+@dataclass(kw_only = True)
+class Float(Rational):
+    """store a rational number in scientific notation as a floating-point number
+
+    example
+    -------
+    significand * radix ** (exponent - precision + 1)
+    S.SSSSSS * RR ^ (EE - P + 1)
+    1.234567 * 10 ^ (89 - 7 + 1)
+
+    notes to myself
+    ---------------
+    when printing to another radix, if input radix and output radix are coprime, you need to specify precision to the equivalent of the input radix. 
+    """
+    radix: int
+    precision: int
+    significand: int
+    exponent: int
+
+    @property
+    def numerator(self) -> int:
+        return self.significand * self.radix ** max(0, self.exponent - self.precision + 1)
+    
+    @property
+    def denominator(self) -> int:
+        return self.radix ** max(0, self.precision - 1 - self.exponent)
+    
+    @classmethod
+    def from_str(cls, string: str, *, radix: int = 10, precision: None | int = None, exponent_marker: str = 'e') -> Float:
+        'construct a Float from a string. radix=10 by default (like builtins.int). precision is inferred.'
+        # '-0,1.2,3E-4,5'
+        string = string.replace(',', '').lower()
+        # '-01.23e-45'
+        significand_str, exponent_str = string.split(exponent_marker, 1) if exponent_marker in string else (string, '0')
+        # '-01.23', '-45'
+        negative = significand_str.startswith('-')
+        digits = significand_str.lstrip('+-0')
+        # -ve, '1.23', '-45'
+        point = digits.find('.') if '.' in digits else len(digits)
+        digits = digits.replace('.', '')
+        # -ve, '123', point=1, '-45'
+        
+        precision = len(digits) if precision is None else precision
+        significand = int(('-' if negative else '') + digits, base=radix)
+        exponent = int(exponent_str, base=radix) + point - 1
+        
+        return cls(radix=radix, precision=precision, significand=significand, exponent=exponent)
+    
+    @classmethod
+    def from_rational(cls, rational: Rational, *, radix: int, precision: int) -> Float:
+        signum = (rational > 0) - (rational < 0)
+
+        significand = abs(rational)
+        exponent = 0
+
+        # get exponent
+        while significand >= radix:
+            exponent += 1
+            significand /= radix
+        
+        # get significand
+        
+        significand = Fixed.from_rational(significand)
+        
+        return cls(radix=radix, precision=precision, significand=significand, exponent=exponent)
+    
+    def __pos__(self): return Float.from_rational(+Fraction(self))
+    def __neg__(self): return Float.from_rational(-Fraction(self))
+    def __abs__(self): return Float.from_rational(abs(Fraction(self)))
+    def __ceil__(self): return Float.from_rational(math.ceil(Fraction(self)))
+    def __floor__(self): return Float.from_rational(math.floor(Fraction(self)))
+    def __round__(self): return Float.from_rational(round(Fraction(self)))
+    def __trunc__(self): return Float.from_rational(math.trunc(Fraction(self)))
+    def __floordiv__(self, other): return Float.from_rational(Fraction(self) // Fraction(other))
+    def __mod__(self, other): return Float.from_rational(Fraction(self) % Fraction(other))
+    def __le__(self, other): return Fraction(self) <= Fraction(other)
+    def __lt__(self, other): return Fraction(self) < Fraction(other)
+    def __add__(self, other): return Float.from_rational(Fraction(self) + Fraction(other))
+    def __mul__(self, other): return Float.from_rational(Fraction(self) * Fraction(other))
+    def __truediv__(self, other): return Float.from_rational(Fraction(self) / Fraction(other))
+    def __pow__(self, other): return Float.from_rational(Fraction(self) ** Fraction(other))
+    def __rfloordiv__(other, self): return Float.from_rational(Fraction(self) // Fraction(other))
+    def __radd__(other, self): return Float.from_rational(Fraction(self) + Fraction(other))
+    def __rmul__(other, self): return Float.from_rational(Fraction(self) * Fraction(other))
+    def __rmod__(other, self): return Float.from_rational(Fraction(self) % Fraction(other))
+    def __rpow__(other, self): return Float.from_rational(Fraction(self) ** Fraction(other))
+    def __rtruediv__(other, self): return Float.from_rational(Fraction(self) / Fraction(other))
+
+    def as_fraction(self) -> Fraction:
+        return Fraction(self)
+
+    def __float__(self) -> builtins.float:
+        return builtins.float(self.as_fraction())
+
+    def __str__(self, *, radix: int = 10, exponent_marker: str = 'e', alphabet: str = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz') -> str:
+        return fraction_to_radix(
+            numerator = self.numerator,
+            denominator = self.denominator,
+            radix = radix,
+            alphabet = alphabet)
+    
+    str = __str__
+
+    __repr__ = daacorations.pretty_repr
+
+def ieee_binary(bits: int) -> type:
+    match bits: 
+        case 16: precision = 11; emin = -  14; emax =   15
+        case 32: precision = 24; emin = - 126; emax =  127
+        case 64: precision = 53; emin = -1022; emax = 1023
+        case  _:
+            if bits < 128 or bits % 32 != 0:
+                raise ValueError('IEEE defines interchange formats for bits: 16, 32, 64, and multiples of 32 ≥128')
+        
+            exponent_digits = round(4 * math.log2(bits)) - 13
+            precision = bits - exponent_digits
+            emax = 2 ** (exponent_digits - 1) - 1
+            emin = 1 - emax
+
+    class IEEE754Binary(Float):
+        'an IEEE 754 binary float'
+    
+        def __init__(self, significand: int, exponent: int):
+            super().__init__(radix=2, precision=precision, significand=significand, exponent=exponent)
+
+        @classmethod
+        def from_str(cls, string) -> IEEE754Binary:
+            return super().from_str(string, radix = 2, precision = precision)
+    
+    return IEEE754Binary, emin, emax
+
+def ieee_decimal(bits: int) -> type:
+    match bits:
+        case 32: precision =  7; emin = - 95; emax =  96
+        case 64: precision = 16; emin = -383; emax = 384
+        case  _:
+            if bits < 128 or bits % 32 != 0:
+                raise ValueError('IEEE defines interchange formats for bits: 32, 64, and multiples of 32 ≥128')
+            
+            precision = 9 * (bits // 32) - 2
+            emax = 3 * 2 ** ((2 * (bits // 32) + 4) - 1)
+            emin = 1 - emax
+
+    class IEEE754Decimal(Float):
+        'an IEEE 754 decimal float'
+    
+        def __init__(self, significand: int, exponent: int):
+            super().__init__(radix=10, precision=precision, significand=significand, exponent=exponent)
+        
+        @classmethod
+        def from_str(cls, string, *, radix = 10) -> IEEE754Decimal:
+            return super().from_str(string, radix = radix, precision = precision)
+        
+    return IEEE754Decimal, emin, emax
+
+f16  = ieee_binary( 16)
+f32  = ieee_binary( 32)
+f64  = ieee_binary( 64)
+f128 = ieee_binary(128)
+f256 = ieee_binary(256)
+
+d32  = ieee_decimal( 32)
+d64  = ieee_decimal( 64)
+d128 = ieee_decimal(128)
+
+
+'''
+f16:
+0 00000 0000000000
+False/True 00001–11110 0000000000
+−/+ [−14, +15] [0/2E10, 1023/2E10]
+
+d32:
+0 000 0000000
+−/+ −95, +96] [0/1E7, 9999999/1E7]
+'''

daatypes/int.py

@@ -0,0 +1,4 @@
+from numbers import Integral
+
+class Int(Integral):
+    ...

daatypes/interval.py

@@ -0,0 +1,5 @@
+import daacorations
+from numbers import Number
+
+class Interval(Number):
+    __repr__ = daacorations.pretty_repr

daatypes/monzo.py

@@ -0,0 +1,286 @@
+import collections, math, daacorations
+from collections.abc import Sequence, MutableSequence, Mapping, MutableMapping, Iterable, Hashable, Container
+from itertools import pairwise, cycle
+from numbers import Integral, Rational
+from frozendefaultdict import frozendefaultdict
+from fractions import Fraction
+from typing import Literal
+from functools import cached_property
+from collections import defaultdict
+
+class Wheel(collections.abc.Iterator):
+    """a wheel for generating primes. its iterator returns the residues of the given wheel size. you get diminishing returns as you go up in size:
+
+    >>> primes = [2,3,5,7,11,13,17,19,23]
+    >>> for i in range(len(primes)):
+    >>>     size = math.prod(primes[:i])
+    >>>     wheel_count = Wheel(size).cycle_size
+    >>>     naïve_count = size
+    >>>     efficiency = wheel_count / naïve_count
+    >>>     print(size, f'{wheel_count}/{naïve_count}={efficiency:.2%}')
+    >>>
+    1 1/1=100.00%
+    2 1/2=50.00%
+    6 2/6=33.33%
+    30 8/30=26.67%
+    210 48/210=22.86%
+    2310 480/2310=20.78%
+    30030 5760/30030=19.18%
+    510510 92160/510510=18.05%
+    9699690 1658880/9699690=17.10%
+    223092870 36495360/223092870=16.36%
+    """
+    
+    @staticmethod
+    def _generate_steps(size: int) -> Sequence[int]:
+        candidates = tuple(filter(lambda candidate: math.gcd(candidate, size) == 1, range(size)))
+        return [b - a for a, b in pairwise(candidates)] + [(candidates[0] - candidates[-1]) % size]
+    
+    def __init__(self, factors: collections.abc.Iterable[int]):
+        'if you pass non-primes as factors, you wont be able to track them at the start of your generator. thats on you, idiot. sorry, harsh words, sorry but if you do that youre kinda dumb.. a bit'
+        size = math.lcm(*factors)
+        
+        if math.prod(factors) != size:
+            raise ValueError('factors must be coprime!')
+        
+        self.size: int = size
+        self.candidate: int = 1
+
+        steps: Sequence[int] = Wheel._generate_steps(size)
+        self.cycle: cycle[int] = cycle(steps)
+        self.cycle_size: int = len(steps)
+        
+        # initialize candidate properly
+        #for factor in factors:  # indexitis
+        #    next(self)
+    
+    def __iter__(self):
+        return self
+    
+    def __next__(self) -> int:
+        self.candidate += next(self.cycle)
+        return self.candidate
+
+    __repr__ = daacorations.pretty_repr
+
+class PrimesIterableContainer(Iterable, Container):
+    """a singleton class representing the infinite sequence of prime numbers. you can do things like:
+    
+    Primes = PrimeSequence()
+    
+    Primes[0] == 2
+    Primes[1] == 3
+    Primes[2] == 5
+    Primes[3] == 7
+
+    assert 5 in Primes
+    assert 13 in Primes
+
+    primes = Primes[:10]
+
+    for prime in Primes[:100]:
+        print(prime)
+
+    uses a 2x3 wheel by default, thus only testing 6*1-1, 6*1+1, 6*2-1, 6*2+1, 6*3-1, 6*3+1, … for generation. larger wheels like 2x3x5, 2x3x5x7, … can be used for better efficiency (see Wheel class)
+    """
+    
+    _cache: MutableSequence[Integral] = [2, 3]
+
+    def __init__(self, wheel_factors: Iterable[int] = [2, 3]):
+        self.wheel: Wheel = Wheel(wheel_factors)
+        self._cache.extend(wheel_factors[len(self._cache):])
+    
+    def _extend_cache_by(self, count: int = 1) -> None:
+        'grow cache by a certain .count of primes'
+
+        while count > 0:
+            candidate = next(self.wheel)
+            
+            # "is candidate prime?"
+            if all(candidate % prime != 0 for prime in self._cache):
+                count -= 1
+                self._cache.append(candidate)
+        
+    def __getitem__(self, index: slice | int):
+        if isinstance(index, slice):
+            self._extend_cache_by(index.stop - len(self._cache))
+        elif isinstance(index, int):
+            if index < 0:
+                raise ValueError('cannot use negative indices on an infinite sequence')
+            self._extend_cache_by(index + 1 - len(self._cache))
+        else:
+            raise TypeError('index must be either slice or int')
+        
+        return self._cache[index]
+
+    def __iter__(self):
+        i = 0
+
+        while True:
+            yield self[i := i + 1]
+        
+    @classmethod
+    def __contains__(cls, number: Natural) -> bool:
+        # number is known (from cache) to be prime
+        if number in cls._cache:
+            return True
+
+        # number is within cache
+        if cls._cache[-1] >= number:
+            return number in cls._cache
+        
+        # number is not within cache. perform divisibility check
+        # this way, cache is generated up to ≥⌊√n⌋ instead of ≥n
+        limit: int = math.floor(math.sqrt(number))
+        
+        for prime in Primes:
+            if prime > limit:
+                return True
+            if number % prime == 0:
+                return False    
+
+    def index(self, number):
+        if number not in self:
+            raise numberError(f'{number} is not prime')
+
+        while self._cache[-1] < number:
+            self._extend_cache_by(1)
+
+        return self._cache.index(number)
+
+    __repr__ = daacorations.pretty_repr
+
+Primes = PrimesIterableContainer()
+
+'''
+# here we dont subclass Rational because surds are not rational!
+class Surd(Real):
+    'like how Integral is a sub(Natural, Natural) pair, and Rational is a div(Integral, Integral) pair, Surd is a root(Integral, Integral) pair. its cousin is the log(Integral, Integral) pair, which i have not named yet. the equivalence class is op(a, b) = op(c, d). so, for example, 2√2 = 4√4'
+
+    def __init__(self, base: Rational, degree: Rational):
+        self.base = base
+        self.degree = degree
+
+    def __float__(self) -> float:
+        return self.base ** (1 / self.degree)
+
+    def __mul__(self, other) -> Surd:
+        return self.base
+'''
+
+class Monzo(Hashable, Sequence):#, Rational):
+    """a datatype that represents rational number stored as prime factors — conceptually as a sparse sequence, implemented as a mapping, but has the interface of a sequence :)
+
+    examples:
+    Monzo(2) = [1⟩     = {0: 1} = 2¹
+    Monzo(3) = [0 1⟩   = {1: 1} = 3¹
+    Monzo(4) = [2⟩     = {0: 2} = 2²
+    Monzo(5) = [0 0 1⟩ = {2: 1} = 5¹
+    """
+    
+    def __init__(self, factors: HashableMapping, sign: Literal[-1, 0, +1] = 1):
+        self.factors: HashableMapping = factors
+        self.sign: Literal[-1, 0, +1] = sign
+    
+    @cached_property
+    def numerator(self) -> Integral:
+        return self.sign * math.prod(Primes[prime_index] ** exponent for prime_index, exponent in self.factors.items() if exponent > 0)
+    
+    @cached_property
+    def denominator(self) -> Integral:
+        return math.prod(Primes[prime_index] ** -exponent for prime_index, exponent in self.factors.items() if exponent < 0)
+    
+    @cached_property
+    def prime_factors(self) -> Mapping[Integral, Integral]:
+        return frozendefaultdict.from_items(int, ((Primes[prime_index], exponent) for prime_index, exponent in self.factors.items()))
+    
+    # to support Sequence interface
+    def __getitem__(self, index: int) -> int:
+        return self.factors[index] if index in self.factors else 0
+    def __len__(self) -> Cardinal:
+        keys = self.factors.keys()
+        return max(keys) + 1 if len(keys) > 0 else 1
+    def __iter__(self):
+        yield from (self.factors[index] for index in range(len(self)))
+    
+    # to support Rational interface
+    def __add__(self, other) -> Monzo:
+        'a / b + c / d = (a * d + b * c) / (b * d)'
+        a, b, c, d = self.numerator, self.denominator, other.numerator, other.denominator
+        return cls.from_parts(a * d + b * c, b * d)
+    def __eq__(self, other) -> bool:
+        'a / b = c / d'
+        a, b, c, d = self.numerator, self.denominator, other.numerator, other.denominator
+        return a * d == b * c
+    def __float__(self) -> float:
+        return self.numerator / self.denominator
+
+    @classmethod
+    def from_prime_factors(cls, prime_factors: Mapping, *args, **kwargs) -> Monzo:
+        return cls(frozendefaultdict.from_items(int, ((Primes.index(factor), exponent) for factor, exponent in prime_factors.items())), *args, **kwargs)
+
+    @staticmethod
+    def _prime_factorize(number: Natural) -> HashableMapping[int, int]:
+        factors: MutableMapping = defaultdict(int)
+    
+        prime_index = 0
+    
+        while number > 1:
+            prime = Primes[prime_index]
+
+            if number % prime == 0:
+                number /= prime
+                if prime_index in factors:
+                    factors[prime_index] += 1
+                else:
+                    factors[prime_index] = 1
+            else:
+                prime_index += 1
+        
+        return frozendefaultdict.from_items(int, factors.items())
+
+    @classmethod
+    def from_parts(cls, numerator: Integral, denominator: Integral) -> Monzo:
+        sign: Integral = int(math.copysign(1.0, numerator * denominator))
+
+        numerator = Monzo._prime_factorize(numerator)
+        denominator = Monzo._prime_factorize(denominator)
+        
+        factors: MutableMapping = defaultdict(int, numerator)
+        
+        for prime_factor, exponent in denominator.items():
+            if prime_factor in factors:
+                factors[prime_factor] -= exponent
+            else:
+                factors[prime_factor] = -exponent
+        
+        return cls(frozendefaultdict.from_items(int, factors.items()), sign)
+
+    @classmethod
+    def from_rational(cls, number: Rational) -> Monzo:
+        return cls.from_parts(number.numerator, number.denominator)
+
+    @classmethod
+    def from_sequence(cls, exponents: Sequence[Integral]) -> Monzo:
+        'construct from a sequence. has to use reversed, len, and indexing'
+        # because we dont want [1⟩ from [1 0 0], not [1 0 0⟩
+        trailing_zero_count: int = 0
+        for exponent in reversed(exponents):
+            if exponent != 0: 
+                break
+            trailing_zero_count += 1
+
+        items = enumerate(exponents if trailing_zero_count == 0 else exponents[:-trailing_zero_count])
+
+        return cls(frozendefaultdict.from_items(int, items))
+
+    def __hash__(self) -> int:
+        return hash(Fraction(self))
+
+    __repr__ = daacorations.pretty_repr
+
+    def __str__(self) -> str:
+        return '[' + ' '.join(str(exponent) for exponent in self) + '⟩'
+
+Rational.register(Monzo)
+

daatypes/octo.py

@@ -0,0 +1,29 @@
+from numbers import Number
+from .vector import Vector
+
+class Octo(Number, Vector):
+    'an octonion'
+    
+    def __init__(self, e0, e1, e2, e3, e4, e5, e6, e7):
+        self.e0 = e0
+        self.e1 = e1
+        self.e2 = e2
+        self.e3 = e3
+        self.e4 = e4
+        self.e5 = e5
+        self.e6 = e6
+        self.e7 = e7
+
+    @classmethod
+    def from_complex(cls, c0, c1, c2, c3):
+        ...
+
+    @classmethod
+    def from_quaternion(cls, q0, q1):
+        ...
+
+    def as_real_matrix(self):
+        ...
+
+    def as_complex_matrix(self):
+        ...

daatypes/polar.py

@@ -0,0 +1,10 @@
+from numbers import Complex, Rational
+from dataclasses import dataclass
+
+@dataclass
+class Polar(Complex):
+    magnitude: Rational
+    angle: Rational
+
+    
+

daatypes/qint.py

@@ -0,0 +1,4 @@
+from numbers import Rational
+
+class QInt(Rational):
+    ...

daatypes/quat.py

@@ -0,0 +1,60 @@
+import math
+from numbers import Number, Real, Complex
+from dataclasses import dataclass
+from daacorations import pretty_repr
+
+@dataclass
+class Quat(Number):
+    'a quaternion. a vector of 4 real numbers with special multiplication rules'
+    
+    w: Real
+    x: Real
+    y: Real
+    z: Real
+    
+    # @property
+    # def real(self) -> float:
+    #     return self.w
+    #
+    # @property
+    # def imag(self) -> tuple[float, float, float]:
+    #     return self.x, self.y, self.z
+    
+    def norm(self) -> Real:
+        #return math.hypot(self.w, self.x, self.y, self.z)
+        return math.sqrt(self.w*self.w + self.x*self.x + self.y*self.y + self.z*self.z)
+    __abs__ = norm
+
+    def unit(self) -> Real:
+        norm = self.norm()
+        return type(self)(self.w/norm, self.x/norm, self.y/norm, self.z/norm)
+
+    @classmethod
+    def from_complex(cls, a: Complex, b: Complex) -> Quat:
+        'construct a quaternion from a pair of complex numbers, by cayley dickson construction'
+        return cls(a.real, a.imag, b.real, b.imag)
+    
+    __repr__ = pretty_repr
+    
+    def __add__(self, other) -> Quat:
+        return type(self)(self.w + other.w, self.x + other.x, self.y + other.y, self.z + other.z)
+    
+    def __sub__(self, other) -> Quat:
+        return type(self)(self.w - other.w, self.x - other.x, self.y - other.y, self.z - other.z)
+    
+    def __mul__(self, other) -> Quat:
+        return 
+    
+    def __str__(self) -> str:
+        return f'({self.w} + {self.x}i + {self.y}j + {self.z}k)'
+    
+    def as_real_matrix(self):
+        return (( self.w, -self.x, -self.y, -self.z), 
+                ( self.x,  self.w, -self.z,  self.y), 
+                ( self.y,  self.z,  self.w, -self.x), 
+                ( self.z, -self.y,  self.x,  self.w))
+    
+    def as_complex_matrix(self):
+        return ((complex( self.w, self.x), complex(self.y,  self.z)),
+                (complex(-self.y, self.z), complex(self.w, -self.x)))
+    

daatypes/real.py

@@ -0,0 +1,16 @@
+import numbers
+from dataclasses import dataclass
+
+@dataclass
+class Real(numbers.Real):
+    value: Real
+    
+    def norm(self) -> Real:
+        return abs(self.value)
+    
+    def unit(self) -> Real:
+        return (self.value > 0) - (self.value < 0)
+    
+    
+    
+    

daatypes/uint.py

@@ -0,0 +1,4 @@
+from numbers import Integral
+
+class UInt(Integral):
+    ...

daatypes/uqint.py

@@ -0,0 +1,4 @@
+from numbers import Rational
+
+class UQInt(Rational):
+    ...

daatypes/vector.py

@@ -0,0 +1,33 @@
+import math
+from collections.abc import Sequence, Iterable
+from numbers import Real
+
+class Vector(Sequence):
+    'an immutable vector'
+    def __init__(self, iterable: Iterable):
+        self.sequence: tuple = tuple(iterable)
+    
+    def norm(self, power = 2) -> Real:
+        if power == 2: 
+            return math.hypot(self.sequence) 
+        else: 
+            return sum(abs(x) ** power for x in self) ** (1 / power)
+    __abs__ = norm
+    
+    def unit(self): 
+        return self / self.norm()
+    
+    # Sequence interface methods
+    def __len__(self):
+        return len(self.sequence)
+    def __getitem__(self, index):
+        return self.sequence[index]
+
+    def __mul__(self, other):
+        if isinstance(other, Real):
+            return type(self)(x * other for x in self)
+    
+    def __truediv__(self, other):
+        if isinstance(other, Real):
+            return type(self)(x / other for x in self)
+    

daatypes-0.1.0.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: daatypes
+Version: 0.1.0
+Summary: i simulate datatypes that i find useful
+Project-URL: Homepage, https://github.com/deftasparagusanaconda/daatypes
+Project-URL: Repository, https://github.com/deftasparagusanaconda/daatypes
+Project-URL: Issues, https://github.com/deftasparagusanaconda/daatypes/issues
+Author: deftasparagusanaconda
+License-Expression: MIT
+License-File: LICENSE
+Keywords: math,numerical
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+a collection of datatypes (or, rather, simulations thereof) that i find useful

daatypes-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+daatypes/__init__.py,sha256=G2On_8PV0cXu5Ygk5QENLzgeDgcmNnOrH-hIjbJ18DU,2258
+daatypes/ball.py,sha256=ezj8sxLNvImTnnruhOXu7xyd8PeEnJDoxSd3of3sJyI,647
+daatypes/cf.py,sha256=RSCQ2MqYLd21Xs3IeBvlneQUMCc3IVtTZACCrm2acy8,2517
+daatypes/comp.py,sha256=Y-TA15E7bF5DM2CeKaRrOJAkStZnAuw1KouODkQmuTM,1473
+daatypes/fixed.py,sha256=ISS9mRVxJM0RRN63nf6tfQCsoJCLIugDu74I8DCMGCs,9475
+daatypes/float.py,sha256=qoDrvFRJFLCCmyZ2SIck7Yjza3PksiOY_TQ3nl716mU,8953
+daatypes/int.py,sha256=1OlqFY3fuVdq9pwAz0FG0gx4YO7Yv-pDXGfS9jeq4ZE,59
+daatypes/interval.py,sha256=Ug-A-vvZXubXK6VrimMpbs15XhXC1AIrXTNXcDTqqjo,112
+daatypes/monzo.py,sha256=uZPkolMfU1iRaAtvnAE3Nb3uTyJsvSMm9e2qQOFbeZo,10392
+daatypes/octo.py,sha256=5INSYFpg6IWA1Ub0194EeuLCbV4dLP6nGgm0www2xoA,560
+daatypes/polar.py,sha256=MwzMLR8I8lbaBt3HNtkvB0Ad6AZHWj625shsAY-avTQ,157
+daatypes/qint.py,sha256=MMhrnfXK_51-3HzbmaaqmxnlZCddjs5igTnYS0SdgSw,60
+daatypes/quat.py,sha256=eIOeG1zYjre7TgooBdBYSVazoc7NRmdTzTReawQftlw,1948
+daatypes/real.py,sha256=riUSsTHuLdGVJEu3UZ2wrnAPtqICVPaJKk179zkv2bE,271
+daatypes/uint.py,sha256=7QDbriz1dv6d2YzJc7b0wyQGtMa-ZzdO7Bj0fv4_iXU,60
+daatypes/uqint.py,sha256=e_W80VNQx2Xn2KMYyenuHojw1jrjcrTaU5gu62P3Vps,61
+daatypes/vector.py,sha256=LvOJ4-srjkI-vuWp9vj3l0E0QY8T2nxGgKWgVI7NsCc,925
+daatypes-0.1.0.dist-info/METADATA,sha256=fjfl770bBtMvaZzsUoFyeFEUexbyxsWIzWVGK4cQMMM,960
+daatypes-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+daatypes-0.1.0.dist-info/licenses/LICENSE,sha256=VB2xlcQdtOxvalPfPY4FykGdH2Aqqjr0NO9YeF_3cyk,1078
+daatypes-0.1.0.dist-info/RECORD,,

daatypes-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

daatypes-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lalremruata Chongmang
+
+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 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.