decoint 0.1.0__tar.gz

decoint-0.1.0/LICENSE

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

decoint-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: decoint
+Version: 0.1.0
+Summary: An IEEE 1788-2015 compliant interval arithmetic library
+Author-email: Arjav Sharma <arjav.sharma.91@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/arjavsharma91/IEEE-1788.1-2017-Interval-Arithmetic
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gmpy2>=2.1.0
+Dynamic: license-file
+
+# IEEE-1788.1-2017 Simplified Standard For Interval Arithmetic Python Implementation
+
+## Key Features
+
+* **IEEE 1788.1-2017 Compliant:** Tested against the official Interval Test Framework (ITF) suite.
+* **Rigorous Enclosure:** Guarantees interval enclosure using directed rounding modes.
+* **Decorated Intervals:** Complete support for interval decorations (`com`, `dac`, `def`, `trv`, `ill`).
+* **High Precision:** Powered by `gmpy2`'s MPFR bindings for fast, arbitrary-precision floating-point arithmetic.
+* **Full Operator Set:** Includes basic arithmetic, set relations/operations, interval queries, functions, and string parsing.
+

decoint-0.1.0/README.md

@@ -0,0 +1,10 @@
+# IEEE-1788.1-2017 Simplified Standard For Interval Arithmetic Python Implementation
+
+## Key Features
+
+* **IEEE 1788.1-2017 Compliant:** Tested against the official Interval Test Framework (ITF) suite.
+* **Rigorous Enclosure:** Guarantees interval enclosure using directed rounding modes.
+* **Decorated Intervals:** Complete support for interval decorations (`com`, `dac`, `def`, `trv`, `ill`).
+* **High Precision:** Powered by `gmpy2`'s MPFR bindings for fast, arbitrary-precision floating-point arithmetic.
+* **Full Operator Set:** Includes basic arithmetic, set relations/operations, interval queries, functions, and string parsing.
+

decoint-0.1.0/decoint/__init__.py

@@ -0,0 +1,23 @@
+from .interval import Interval
+from .decorated_interval import DecoratedInterval
+from .decorations import Decoration
+
+# 2. Fully Tracked Core Arithmetic (Using your decorated module)
+from .decorated_arithmetic import add, sub, mul, div, reciprocal, fma
+
+# 3. Tracked Elementary Functions 
+from .decorated_functions import (
+    exp, log, sqrt, pow_int, sign, 
+    sin, cos, tan, asin, acos, atan, 
+    sinh, cosh, tanh, asinh, acosh, atanh, 
+    abs, atan2, interval_min, interval_max, nth_root, sqr, pow_interval, exp2, exp10, log2, log10, interval_trunc, interval_ceil, interval_floor
+)
+
+__all__ = [
+    'Interval', 'DecoratedInterval', 'Decoration',
+    'add', 'sub', 'mul', 'div', 'reciprocal',
+    'exp', 'log', 'sqrt', 'pow_int', 'sign',
+    'sin', 'cos', 'tan', 'asin', 'acos', 'atan',
+    'sinh', 'cosh', 'tanh', 'asinh', 'acosh', 'atanh',
+    'abs', 'atan2', 'interval_min', 'interval_max', 'nth_root', 'sqr', 'fma', 'pow_interval', 'exp2', 'exp10', 'log2', 'log10', 'interval_trunc', 'interval_ceil', 'interval_floor'
+]

decoint-0.1.0/decoint/arithmetic.py

@@ -0,0 +1,181 @@
+from .interval import Interval
+from .rounding import add_down, add_up, sub_down, sub_up, div_down, div_up, mul_down, mul_up, fma_up, fma_down
+from gmpy2 import mpfr, is_infinite, is_signed, sign, context, get_context
+
+ctx = get_context()
+ctx.precision = 53
+ctx.emin = -1073
+ctx.emax = 1024
+
+def add(x, y) -> Interval:
+  x = Interval._coerce(x)
+  y = Interval._coerce(y)
+  if x.is_empty or y.is_empty:
+    return Interval.empty()
+  lo = add_down(x.lo, y.lo)
+  hi = add_up(x.hi, y.hi)
+  return Interval(lo, hi)
+
+def sub(x, y) -> Interval:
+  x = Interval._coerce(x)
+  y = Interval._coerce(y)
+  if x.is_empty or y.is_empty:
+    return Interval.empty()
+  lo = sub_down(x.lo, y.hi)
+  hi = sub_up(x.hi, y.lo)
+  return Interval(lo, hi)
+
+def mul(x, y) -> Interval:
+  x = Interval._coerce(x)
+  y = Interval._coerce(y)
+  if x.is_empty or y.is_empty:
+    return Interval.empty()
+
+  def safe_mul_down(a, b):
+    if (a == 0 and is_infinite(b)) or (b == 0 and is_infinite(a)):
+      is_neg = is_signed(a) * is_signed(b)
+      return mpfr('0') if is_neg else mpfr('-0.0')
+    return mul_down(a, b)
+
+  def safe_mul_up(a, b):
+    if (a == 0 and is_infinite(b)) or (b == 0 and is_infinite(a)):
+      is_neg = is_signed(a) * is_signed(b)
+      return mpfr('0') if is_neg else mpfr('-0.0')
+    return mul_up(a, b)
+
+  p1 = safe_mul_down(x.lo, y.lo)
+  p2 = safe_mul_down(x.lo, y.hi)
+  p3 = safe_mul_down(x.hi, y.lo)
+  p4 = safe_mul_down(x.hi, y.hi)
+  
+  lo = min(p1, p2, p3, p4)
+
+  q1 = safe_mul_up(x.lo, y.lo)
+  q2 = safe_mul_up(x.lo, y.hi)
+  q3 = safe_mul_up(x.hi, y.lo)
+  q4 = safe_mul_up(x.hi, y.hi)
+  
+  hi = max(q1, q2, q3, q4)
+
+  return Interval(lo, hi)
+
+def reciprocal(x) -> Interval:
+  x = Interval._coerce(x)
+  if x.is_empty:
+    return Interval.empty()
+  if x.contains_zero:
+    if x.lo == 0 and x.hi == 0:
+      return Interval.empty()
+    if x.lo == 0:
+      return Interval(div_down(mpfr(1), x.hi), mpfr('inf'))
+    if x.hi == 0:
+      return Interval(mpfr('-inf'), div_up(mpfr(1), x.lo))
+    return Interval.entire()
+
+  return Interval(div_down(mpfr(1), x.hi), div_up(mpfr(1), x.lo))
+
+def div(x, y) -> Interval:
+  x = Interval._coerce(x)
+  y = Interval._coerce(y)
+  if x.is_empty or y.is_empty:
+    return Interval.empty()
+
+  if x.is_entire and not y.contains(0):
+    return Interval.entire()
+
+  if y.contains(0):
+    if y.hi == 0 and y.lo == 0:
+      return Interval.empty()
+    if x.hi == 0 and x.lo == 0:
+      return Interval(mpfr('0'), mpfr('0'))
+    if x.lo >= 0:
+      if y.lo == 0:
+        return Interval(div_down(x.lo, y.hi), mpfr('inf'))
+      elif y.hi == 0:
+        return Interval(mpfr('-inf'), div_up(x.lo, y.lo))
+      else:
+        return Interval.entire()        
+    elif x.hi <= 0:
+      if y.lo == 0:
+        return Interval(mpfr('-inf'), div_up(x.hi, y.hi))
+      elif y.hi == 0:
+        return Interval(div_down(x.hi, y.lo), mpfr('inf'))
+      else:
+        return Interval.entire()
+    else:
+      return Interval.entire()
+
+  # --- CLEAN DIRECT REPLACEMENT FOR mul(x, reciprocal(y)) ---
+  if y.lo > 0:  # Denominator is strictly positive
+    # Lower bound logic
+    if x.lo == mpfr('-inf'):
+      lo = mpfr('-inf')
+    else:
+      lo = div_down(x.lo, y.hi if x.lo >= 0 else y.lo)
+    
+    # Upper bound logic
+    if x.hi == mpfr('inf'):
+      hi = mpfr('inf')
+    else:
+      hi = div_up(x.hi, y.lo if x.hi >= 0 else y.hi)
+      
+  else:  # Denominator is strictly negative (y.hi < 0)
+    # Lower bound logic
+    if x.hi == mpfr('inf'):
+      lo = mpfr('-inf')
+    else:
+      lo = div_down(x.hi, y.hi if x.hi >= 0 else y.lo)
+      
+    # Upper bound logic
+    if x.lo == mpfr('-inf'):
+      hi = mpfr('inf')
+    else:
+      hi = div_up(x.lo, y.lo if x.lo >= 0 else y.hi)
+
+  return Interval(lo, hi)
+
+def evaluate_fma_corner(x, y, z, round_up=False):
+  # 1. Handle 0 * inf indeterminate form -> results in 0, so 0 + z = z
+  if (x == 0 and is_infinite(y)) or (is_infinite(x) and y == 0):
+    return z
+
+  # 2. Handle true inf - inf indeterminate form
+  if is_infinite(x) or is_infinite(y):
+    if is_infinite(z):
+      prod_neg = (x < 0) != (y < 0)
+      z_neg = z < 0
+      # If the infinite product's sign opposes z's infinite sign, it's inf - inf
+      if prod_neg != z_neg:
+        return None  # Signal containment explosion
+
+  # Safe to compute standard hardware rounded FMA
+  return fma_up(x, y, z) if round_up else fma_down(x, y, z)
+
+
+def fma(x, y, z):
+  x = Interval._coerce(x)
+  y = Interval._coerce(y)
+  z = Interval._coerce(z)
+
+  if x.is_empty or y.is_empty or z.is_empty:
+    return Interval.empty()
+
+  # Evaluate lower bound corner combinations
+  v_down = []
+  for cx in (x.lo, x.hi):
+    for cy in (y.lo, y.hi):
+      val = evaluate_fma_corner(cx, cy, z.lo, round_up=False)
+      if val is None:
+        return Interval.entire()
+      v_down.append(val)
+
+  # Evaluate upper bound corner combinations
+  v_up = []
+  for cx in (x.lo, x.hi):
+    for cy in (y.lo, y.hi):
+      val = evaluate_fma_corner(cx, cy, z.hi, round_up=True)
+      if val is None:
+        return Interval.entire()
+      v_up.append(val)
+
+  return Interval(min(v_down), max(v_up))

decoint-0.1.0/decoint/constants.py

@@ -0,0 +1,6 @@
+from gmpy2 import const_pi, context, get_context
+
+with context(get_context(), precision = 128):
+    PI = const_pi()
+    HALF_PI = PI / 2
+    TWO_PI = PI * 2

decoint-0.1.0/decoint/decorated_arithmetic.py

@@ -0,0 +1,98 @@
+from .interval import Interval
+from .arithmetic import add as bare_add, sub as bare_sub, mul as bare_mul, div as bare_div, reciprocal as bare_reciprocal, fma as bare_fma
+from .decorations import Decoration, combine
+from .decorated_interval import DecoratedInterval
+
+def _finalize_decoration(base_dec: Decoration, interval: Interval) -> Decoration:
+  if base_dec == Decoration.COM and not interval.is_bounded:
+    return Decoration.DAC
+  return base_dec
+
+def add(x, y):
+  x = DecoratedInterval._coerce(x)
+  y = DecoratedInterval._coerce(y)
+
+  if x.is_nai or y.is_nai:
+    return DecoratedInterval.new_nai()
+
+  interval = bare_add(x.interval, y.interval)
+  dec = combine(x.decoration, y.decoration)
+  dec = _finalize_decoration(dec, interval)
+
+  return DecoratedInterval(interval, dec)
+
+def sub(x, y):
+  x = DecoratedInterval._coerce(x)
+  y = DecoratedInterval._coerce(y)
+
+  if x.is_nai or y.is_nai:
+    return DecoratedInterval.new_nai()
+
+  interval = bare_sub(x.interval, y.interval)
+  dec = combine(x.decoration, y.decoration)
+  dec = _finalize_decoration(dec, interval)
+
+  return DecoratedInterval(interval, dec)
+
+def mul(x, y):
+  x = DecoratedInterval._coerce(x)
+  y = DecoratedInterval._coerce(y)
+
+  if x.is_nai or y.is_nai:
+    return DecoratedInterval.new_nai()
+
+  interval = bare_mul(x.interval, y.interval)
+  dec = combine(x.decoration, y.decoration)
+  dec = _finalize_decoration(dec, interval)
+
+  return DecoratedInterval(interval, dec)
+
+def reciprocal(x):
+  x = DecoratedInterval._coerce(x)
+  if x.is_nai:
+    return DecoratedInterval.new_nai()
+  if x.interval.contains(0):
+    if x.interval.lo < 0 and x.interval.hi > 0:
+      return DecoratedInterval(Interval.entire(), Decoration.TRV)
+    interval = bare_reciprocal(x.interval)
+    return DecoratedInterval(interval, Decoration.TRV)
+  interval = bare_reciprocal(x.interval)
+  dec = x.decoration
+  dec = _finalize_decoration(dec, interval)
+  return DecoratedInterval(interval, dec)
+
+def div(x, y):
+  x = DecoratedInterval._coerce(x)
+  y = DecoratedInterval._coerce(y)
+
+  if x.is_nai or y.is_nai:
+    return DecoratedInterval.new_nai()
+
+  if x.is_empty or y.is_empty:
+    return DecoratedInterval.empty()
+
+  if y.interval.contains(0):
+      interval = bare_div(x.interval, y.interval)
+      dec = combine(x.decoration, y.decoration, Decoration.TRV)
+      return DecoratedInterval(interval, Decoration.TRV)
+
+  interval = bare_div(x.interval, y.interval)
+  dec = combine(x.decoration, y.decoration)
+  dec = _finalize_decoration(dec, interval)
+
+  return DecoratedInterval(interval, dec)
+
+def fma(x, y, z):
+  x = DecoratedInterval._coerce(x)
+  y = DecoratedInterval._coerce(y)
+  z = DecoratedInterval._coerce(z)
+
+  if x.is_nai or y.is_nai or z.is_nai:
+    return DecoratedInterval.new_nai()
+
+  interval = bare_fma(x.interval, y.interval, z.interval)
+  dec = combine(x.decoration, y.decoration, z.decoration)
+
+  dec = _finalize_decoration(dec, interval)
+
+  return DecoratedInterval(interval, dec)