simple-portable-numeric 0.0.1__py3-none-any.whl

simple_portable_numeric/__init__.py

@@ -0,0 +1,6 @@
+# coding: utf-8
+from simple_portable_numeric.enum_rounding_mode import EnumRoundingMode
+from simple_portable_numeric.portable_decimal import PortableDecimal
+from simple_portable_numeric.portable_rational import PortableRational
+
+__all__ = ["EnumRoundingMode", "PortableDecimal", "PortableRational"]

simple_portable_numeric/enum_rounding_mode.py

@@ -0,0 +1,17 @@
+# coding: utf-8
+from enum import Enum
+
+
+class EnumRoundingMode(Enum):
+    """
+    (en) Rounding modes used when an exact value must be reduced to fewer digits.
+    The member names and behavior are identical to the Dart version.
+
+    (ja) 正確な値を少ない桁数に丸める際の丸めモードです。
+    メンバー名と動作はDart版と同一です。
+    """
+    halfEven = "halfEven"  # Nearest, ties to even (banker's rounding).
+    halfUp = "halfUp"  # Nearest, ties away from zero.
+    down = "down"  # Toward zero.
+    floor = "floor"  # Toward negative infinity.
+    ceiling = "ceiling"  # Toward positive infinity.

simple_portable_numeric/portable_decimal.py

@@ -0,0 +1,313 @@
+# coding: utf-8
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from simple_portable_numeric.enum_rounding_mode import EnumRoundingMode
+from simple_portable_numeric.util_int_math import digits_to_int, int_to_digits, ratio_to_float, round_div
+
+if TYPE_CHECKING:
+    from simple_portable_numeric.portable_rational import PortableRational
+
+_DECIMAL_PATTERN = re.compile(r"[+-]?[0-9]+(\.[0-9]+)?")
+
+
+def _check_int(value: object, name: str) -> None:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{name} must be int, got {type(value).__name__}")
+
+
+class PortableDecimal:
+    """
+    (en) An arbitrary-precision decimal number, represented as
+    unscaled_value * 10^(-scale).
+    The results are identical to the Dart version of this package.
+    Equality is by numeric value (1.50 == 1.5), while to_string keeps the scale.
+
+    (ja) 任意精度の10進数です。unscaled_value * 10^(-scale) として表現されます。
+    計算結果はこのパッケージのDart版と同一になります。
+    等価判定は数値で行われ（1.50 == 1.5）、文字列化ではscaleが保持されます。
+    """
+    __slots__ = ("_unscaled_value", "_scale")
+
+    def __init__(self, unscaled_value: int, scale: int = 0):
+        """
+        (en) Creates a decimal whose value is unscaled_value * 10^(-scale).
+
+        (ja) 値が unscaled_value * 10^(-scale) の10進数を作成します。
+
+        Parameters
+        ----------
+        unscaled_value: int
+            The integer value with the decimal point removed.
+        scale: int
+            The number of digits after the decimal point. Must be 0 or more.
+        """
+        _check_int(unscaled_value, "unscaled_value")
+        _check_int(scale, "scale")
+        if scale < 0:
+            raise ValueError(f"scale must be 0 or more, got {scale}")
+        self._unscaled_value = unscaled_value
+        self._scale = scale
+
+    @classmethod
+    def parse(cls, text: str) -> PortableDecimal:
+        """
+        (en) Parses a plain decimal string such as "-12.340".
+        The number of fractional digits becomes the scale.
+        Exponent notation, whitespace and non-ASCII digits are rejected.
+
+        (ja) "-12.340" のような通常表記の10進文字列を解析します。
+        小数部の桁数がscaleになります。
+        指数表記、空白、ASCII以外の数字は受け付けません。
+
+        Parameters
+        ----------
+        text: str
+            The string to parse.
+
+        Returns
+        -------
+        PortableDecimal
+            The parsed value.
+
+        Raises
+        ------
+        ValueError
+            If the string is not a valid decimal.
+        """
+        if not isinstance(text, str):
+            raise TypeError(f"text must be str, got {type(text).__name__}")
+        if _DECIMAL_PATTERN.fullmatch(text) is None:
+            raise ValueError(f"Invalid decimal string: {text!r}")
+        int_part, _, frac_part = text.partition(".")
+        negative = int_part.startswith("-")
+        value = digits_to_int(int_part.lstrip("+-") + frac_part)
+        return cls(-value if negative else value, len(frac_part))
+
+    @property
+    def unscaled_value(self) -> int:
+        """
+        (en) The integer value with the decimal point removed.
+
+        (ja) 小数点を取り除いた整数値です。
+        """
+        return self._unscaled_value
+
+    @property
+    def scale(self) -> int:
+        """
+        (en) The number of digits after the decimal point.
+
+        (ja) 小数点以下の桁数です。
+        """
+        return self._scale
+
+    def _aligned(self, other: PortableDecimal) -> tuple[int, int, int]:
+        """Returns (self unscaled, other unscaled, common scale)."""
+        scale = max(self._scale, other._scale)
+        return (self._unscaled_value * 10 ** (scale - self._scale),
+                other._unscaled_value * 10 ** (scale - other._scale),
+                scale)
+
+    def __add__(self, other: object) -> PortableDecimal:
+        if not isinstance(other, PortableDecimal):
+            return NotImplemented
+        a, b, scale = self._aligned(other)
+        return PortableDecimal(a + b, scale)
+
+    def __sub__(self, other: object) -> PortableDecimal:
+        if not isinstance(other, PortableDecimal):
+            return NotImplemented
+        a, b, scale = self._aligned(other)
+        return PortableDecimal(a - b, scale)
+
+    def __mul__(self, other: object) -> PortableDecimal:
+        if not isinstance(other, PortableDecimal):
+            return NotImplemented
+        return PortableDecimal(self._unscaled_value * other._unscaled_value, self._scale + other._scale)
+
+    def __neg__(self) -> PortableDecimal:
+        return PortableDecimal(-self._unscaled_value, self._scale)
+
+    def __abs__(self) -> PortableDecimal:
+        return PortableDecimal(abs(self._unscaled_value), self._scale)
+
+    def divide(self, other: PortableDecimal, scale: int, rounding: EnumRoundingMode) -> PortableDecimal:
+        """
+        (en) Divides this value by other. The exact quotient is rounded once
+        to the specified number of fractional digits.
+
+        (ja) この値を other で割ります。正確な商を、指定した小数点以下の桁数に
+        1回だけ丸めます。
+
+        Parameters
+        ----------
+        other: PortableDecimal
+            The divisor.
+        scale: int
+            The number of digits after the decimal point of the result. Must be 0 or more.
+        rounding: EnumRoundingMode
+            The rounding mode.
+
+        Returns
+        -------
+        PortableDecimal
+            The rounded quotient.
+
+        Raises
+        ------
+        ZeroDivisionError
+            If other is zero.
+        """
+        if not isinstance(other, PortableDecimal):
+            raise TypeError(f"other must be PortableDecimal, got {type(other).__name__}")
+        _check_int(scale, "scale")
+        if scale < 0:
+            raise ValueError(f"scale must be 0 or more, got {scale}")
+        if other._unscaled_value == 0:
+            raise ZeroDivisionError("Division by zero")
+        # result = (a / 10^sa) / (b / 10^sb) * 10^scale = a * 10^(scale + sb - sa) / b
+        exp = scale + other._scale - self._scale
+        n = self._unscaled_value
+        d = other._unscaled_value
+        if exp >= 0:
+            n *= 10 ** exp
+        else:
+            d *= 10 ** (-exp)
+        return PortableDecimal(round_div(n, d, rounding), scale)
+
+    def set_scale(self, scale: int, rounding: EnumRoundingMode) -> PortableDecimal:
+        """
+        (en) Returns a value with the specified scale. Increasing the scale is exact;
+        decreasing it rounds once with the specified rounding mode.
+
+        (ja) 指定したscaleの値を返します。scaleを増やす場合は正確に、
+        減らす場合は指定した丸めモードで1回だけ丸めます。
+
+        Parameters
+        ----------
+        scale: int
+            The new number of digits after the decimal point. Must be 0 or more.
+        rounding: EnumRoundingMode
+            The rounding mode used when the scale decreases.
+
+        Returns
+        -------
+        PortableDecimal
+            The rescaled value.
+        """
+        _check_int(scale, "scale")
+        if scale < 0:
+            raise ValueError(f"scale must be 0 or more, got {scale}")
+        if scale >= self._scale:
+            return PortableDecimal(self._unscaled_value * 10 ** (scale - self._scale), scale)
+        return PortableDecimal(round_div(self._unscaled_value, 10 ** (self._scale - scale), rounding), scale)
+
+    def compare_to(self, other: PortableDecimal) -> int:
+        """
+        (en) Compares by numeric value.
+
+        (ja) 数値で比較します。
+
+        Parameters
+        ----------
+        other: PortableDecimal
+            The value to compare with.
+
+        Returns
+        -------
+        int
+            -1 if this < other, 0 if equal, 1 if this > other.
+        """
+        if not isinstance(other, PortableDecimal):
+            raise TypeError(f"other must be PortableDecimal, got {type(other).__name__}")
+        a, b, _ = self._aligned(other)
+        return (a > b) - (a < b)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PortableDecimal):
+            return NotImplemented
+        return self.compare_to(other) == 0
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, PortableDecimal):
+            return NotImplemented
+        return self.compare_to(other) < 0
+
+    def __le__(self, other: object) -> bool:
+        if not isinstance(other, PortableDecimal):
+            return NotImplemented
+        return self.compare_to(other) <= 0
+
+    def __gt__(self, other: object) -> bool:
+        if not isinstance(other, PortableDecimal):
+            return NotImplemented
+        return self.compare_to(other) > 0
+
+    def __ge__(self, other: object) -> bool:
+        if not isinstance(other, PortableDecimal):
+            return NotImplemented
+        return self.compare_to(other) >= 0
+
+    def __hash__(self) -> int:
+        u, s = self._unscaled_value, self._scale
+        while s > 0 and u % 10 == 0:
+            u //= 10
+            s -= 1
+        return hash((u, s))
+
+    def to_rational(self) -> PortableRational:
+        """
+        (en) Converts this value to an exactly equal rational.
+
+        (ja) この値を、正確に等しい有理数に変換します。
+
+        Returns
+        -------
+        PortableRational
+            The equal rational value.
+        """
+        from simple_portable_numeric.portable_rational import PortableRational
+        return PortableRational(self._unscaled_value, 10 ** self._scale)
+
+    def to_float(self) -> float:
+        """
+        (en) Converts this value to the nearest double (ties to even).
+        Overflow returns +-inf. The result is identical to toDouble in Dart.
+
+        (ja) この値を最も近い倍精度浮動小数点数に変換します（同距離は偶数側）。
+        範囲外の場合は +-inf を返します。結果はDart版の toDouble と同一です。
+
+        Returns
+        -------
+        float
+            The converted value.
+        """
+        return ratio_to_float(self._unscaled_value, 10 ** self._scale)
+
+    def to_string(self) -> str:
+        """
+        (en) Returns the plain-notation string keeping the scale, e.g. "-1.50".
+        Negative zero is never output.
+
+        (ja) scaleを保持した通常表記の文字列を返します（例: "-1.50"）。
+        負のゼロは出力されません。
+
+        Returns
+        -------
+        str
+            The string representation.
+        """
+        digits = int_to_digits(abs(self._unscaled_value))
+        if self._scale > 0:
+            digits = digits.rjust(self._scale + 1, "0")
+            digits = digits[:-self._scale] + "." + digits[-self._scale:]
+        return "-" + digits if self._unscaled_value < 0 else digits
+
+    def __str__(self) -> str:
+        return self.to_string()
+
+    def __repr__(self) -> str:
+        return f"PortableDecimal('{self.to_string()}')"

simple_portable_numeric/portable_rational.py

@@ -0,0 +1,255 @@
+# coding: utf-8
+from __future__ import annotations
+
+import math
+import re
+
+from simple_portable_numeric.enum_rounding_mode import EnumRoundingMode
+from simple_portable_numeric.portable_decimal import PortableDecimal
+from simple_portable_numeric.util_int_math import digits_to_int, int_to_digits, ratio_to_float, round_div
+
+_FRACTION_PATTERN = re.compile(r"([+-]?)([0-9]+)/([0-9]+)")
+_DECIMAL_PATTERN = re.compile(r"[+-]?[0-9]+(\.[0-9]+)?")
+
+
+def _check_int(value: object, name: str) -> None:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"{name} must be int, got {type(value).__name__}")
+
+
+class PortableRational:
+    """
+    (en) An exact rational number numerator / denominator.
+    It is always kept in canonical form: reduced, with a positive denominator.
+    The results are identical to the Dart version of this package.
+
+    (ja) 分子 / 分母 で表される正確な有理数です。
+    常に約分済みで分母が正の正規形で保持されます。
+    計算結果はこのパッケージのDart版と同一になります。
+    """
+    __slots__ = ("_numerator", "_denominator")
+
+    def __init__(self, numerator: int, denominator: int = 1):
+        """
+        (en) Creates numerator / denominator, reduced to canonical form.
+
+        (ja) 分子 / 分母 を作成し、正規形に約分します。
+
+        Parameters
+        ----------
+        numerator: int
+            The numerator.
+        denominator: int
+            The denominator. Must not be zero.
+
+        Raises
+        ------
+        ZeroDivisionError
+            If denominator is zero.
+        """
+        _check_int(numerator, "numerator")
+        _check_int(denominator, "denominator")
+        if denominator == 0:
+            raise ZeroDivisionError("Division by zero")
+        if denominator < 0:
+            numerator, denominator = -numerator, -denominator
+        g = math.gcd(numerator, denominator)
+        self._numerator = numerator // g
+        self._denominator = denominator // g
+
+    @classmethod
+    def parse(cls, text: str) -> PortableRational:
+        """
+        (en) Parses "n/d", an integer such as "-3", or a plain decimal such as "0.75".
+        The result is reduced to canonical form.
+
+        (ja) "n/d"、"-3" のような整数、"0.75" のような通常表記の10進数を解析します。
+        結果は正規形に約分されます。
+
+        Parameters
+        ----------
+        text: str
+            The string to parse.
+
+        Returns
+        -------
+        PortableRational
+            The parsed value.
+
+        Raises
+        ------
+        ValueError
+            If the string is not a valid format.
+        ZeroDivisionError
+            If the denominator is zero.
+        """
+        if not isinstance(text, str):
+            raise TypeError(f"text must be str, got {type(text).__name__}")
+        m = _FRACTION_PATTERN.fullmatch(text)
+        if m is not None:
+            n = digits_to_int(m.group(2))
+            return cls(-n if m.group(1) == "-" else n, digits_to_int(m.group(3)))
+        if _DECIMAL_PATTERN.fullmatch(text) is not None:
+            return PortableDecimal.parse(text).to_rational()
+        raise ValueError(f"Invalid rational string: {text!r}")
+
+    @property
+    def numerator(self) -> int:
+        """
+        (en) The numerator in canonical form.
+
+        (ja) 正規形での分子です。
+        """
+        return self._numerator
+
+    @property
+    def denominator(self) -> int:
+        """
+        (en) The denominator in canonical form (always positive).
+
+        (ja) 正規形での分母です（常に正）。
+        """
+        return self._denominator
+
+    def __add__(self, other: object) -> PortableRational:
+        if not isinstance(other, PortableRational):
+            return NotImplemented
+        return PortableRational(self._numerator * other._denominator + other._numerator * self._denominator,
+                                self._denominator * other._denominator)
+
+    def __sub__(self, other: object) -> PortableRational:
+        if not isinstance(other, PortableRational):
+            return NotImplemented
+        return PortableRational(self._numerator * other._denominator - other._numerator * self._denominator,
+                                self._denominator * other._denominator)
+
+    def __mul__(self, other: object) -> PortableRational:
+        if not isinstance(other, PortableRational):
+            return NotImplemented
+        return PortableRational(self._numerator * other._numerator, self._denominator * other._denominator)
+
+    def __truediv__(self, other: object) -> PortableRational:
+        if not isinstance(other, PortableRational):
+            return NotImplemented
+        if other._numerator == 0:
+            raise ZeroDivisionError("Division by zero")
+        return PortableRational(self._numerator * other._denominator, self._denominator * other._numerator)
+
+    def __neg__(self) -> PortableRational:
+        return PortableRational(-self._numerator, self._denominator)
+
+    def __abs__(self) -> PortableRational:
+        return PortableRational(abs(self._numerator), self._denominator)
+
+    def compare_to(self, other: PortableRational) -> int:
+        """
+        (en) Compares by numeric value.
+
+        (ja) 数値で比較します。
+
+        Parameters
+        ----------
+        other: PortableRational
+            The value to compare with.
+
+        Returns
+        -------
+        int
+            -1 if this < other, 0 if equal, 1 if this > other.
+        """
+        if not isinstance(other, PortableRational):
+            raise TypeError(f"other must be PortableRational, got {type(other).__name__}")
+        a = self._numerator * other._denominator
+        b = other._numerator * self._denominator
+        return (a > b) - (a < b)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PortableRational):
+            return NotImplemented
+        return self._numerator == other._numerator and self._denominator == other._denominator
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, PortableRational):
+            return NotImplemented
+        return self.compare_to(other) < 0
+
+    def __le__(self, other: object) -> bool:
+        if not isinstance(other, PortableRational):
+            return NotImplemented
+        return self.compare_to(other) <= 0
+
+    def __gt__(self, other: object) -> bool:
+        if not isinstance(other, PortableRational):
+            return NotImplemented
+        return self.compare_to(other) > 0
+
+    def __ge__(self, other: object) -> bool:
+        if not isinstance(other, PortableRational):
+            return NotImplemented
+        return self.compare_to(other) >= 0
+
+    def __hash__(self) -> int:
+        return hash((self._numerator, self._denominator))
+
+    def to_decimal(self, scale: int, rounding: EnumRoundingMode) -> PortableDecimal:
+        """
+        (en) Converts this value to a decimal with the specified scale,
+        rounding the exact value once.
+
+        (ja) この値を指定したscaleの10進数に変換します。正確な値を1回だけ丸めます。
+
+        Parameters
+        ----------
+        scale: int
+            The number of digits after the decimal point. Must be 0 or more.
+        rounding: EnumRoundingMode
+            The rounding mode.
+
+        Returns
+        -------
+        PortableDecimal
+            The converted value.
+        """
+        _check_int(scale, "scale")
+        if scale < 0:
+            raise ValueError(f"scale must be 0 or more, got {scale}")
+        return PortableDecimal(round_div(self._numerator * 10 ** scale, self._denominator, rounding), scale)
+
+    def to_float(self) -> float:
+        """
+        (en) Converts this value to the nearest double (ties to even).
+        Overflow returns +-inf. The result is identical to toDouble in Dart.
+
+        (ja) この値を最も近い倍精度浮動小数点数に変換します（同距離は偶数側）。
+        範囲外の場合は +-inf を返します。結果はDart版の toDouble と同一です。
+
+        Returns
+        -------
+        float
+            The converted value.
+        """
+        return ratio_to_float(self._numerator, self._denominator)
+
+    def to_string(self) -> str:
+        """
+        (en) Returns "n/d", or "n" when the denominator is 1.
+
+        (ja) "n/d" を返します。分母が1の場合は "n" を返します。
+
+        Returns
+        -------
+        str
+            The string representation.
+        """
+        n = int_to_digits(abs(self._numerator))
+        if self._numerator < 0:
+            n = "-" + n
+        if self._denominator == 1:
+            return n
+        return n + "/" + int_to_digits(self._denominator)
+
+    def __str__(self) -> str:
+        return self.to_string()
+
+    def __repr__(self) -> str:
+        return f"PortableRational('{self.to_string()}')"

simple_portable_numeric/util_int_math.py

@@ -0,0 +1,135 @@
+# coding: utf-8
+import math
+
+from simple_portable_numeric.enum_rounding_mode import EnumRoundingMode
+
+
+def round_div(n: int, d: int, rounding: EnumRoundingMode) -> int:
+    """
+    (en) Divides n by d exactly and rounds the quotient to an integer once.
+
+    (ja) n を d で正確に割り、商を1回だけ丸めて整数にします。
+
+    Parameters
+    ----------
+    n: int
+        The dividend.
+    d: int
+        The divisor. Must not be zero.
+    rounding: EnumRoundingMode
+        The rounding mode.
+
+    Returns
+    -------
+    int
+        The rounded quotient.
+    """
+    if d == 0:
+        raise ZeroDivisionError("Division by zero")
+    if d < 0:
+        n, d = -n, -d
+    q, r = divmod(n, d)  # q = floor(n / d), 0 <= r < d
+    if r == 0:
+        return q
+    if rounding is EnumRoundingMode.floor:
+        return q
+    if rounding is EnumRoundingMode.ceiling:
+        return q + 1
+    if rounding is EnumRoundingMode.down:
+        return q if n >= 0 else q + 1
+    twice = 2 * r
+    if twice < d:
+        return q
+    if twice > d:
+        return q + 1
+    if rounding is EnumRoundingMode.halfUp:
+        return q + 1 if n >= 0 else q
+    if rounding is EnumRoundingMode.halfEven:
+        return q if q % 2 == 0 else q + 1
+    raise ValueError(f"Unsupported rounding mode: {rounding}")
+
+
+def ratio_to_float(n: int, d: int) -> float:
+    """
+    (en) Converts the exact ratio n / d to the nearest IEEE 754 double
+    (ties to even). Overflow returns +-inf.
+
+    (ja) 正確な比 n / d を最も近いIEEE 754倍精度浮動小数点数に変換します
+    （同距離は偶数側）。範囲外の場合は +-inf を返します。
+
+    Parameters
+    ----------
+    n: int
+        The numerator.
+    d: int
+        The denominator. Must be positive.
+
+    Returns
+    -------
+    float
+        The correctly rounded double value.
+    """
+    try:
+        # CPython's int / int is correctly rounded, including subnormals.
+        return n / d
+    except OverflowError:
+        return math.inf if n > 0 else -math.inf
+
+
+_CHUNK = 1000
+_CHUNK_BASE = 10 ** _CHUNK
+
+
+def digits_to_int(digits: str) -> int:
+    """
+    (en) Converts a string of ASCII digits to a non-negative int.
+    Unlike int(), this is not limited by sys.get_int_max_str_digits(),
+    so the same strings are accepted as in the Dart version.
+
+    (ja) ASCII数字の文字列を非負の整数に変換します。
+    int() と異なり sys.get_int_max_str_digits() の制限を受けないため、
+    Dart版と同じ文字列を受け付けます。
+
+    Parameters
+    ----------
+    digits: str
+        A non-empty string consisting only of "0"-"9".
+
+    Returns
+    -------
+    int
+        The converted value.
+    """
+    result = 0
+    for i in range(0, len(digits), _CHUNK):
+        chunk = digits[i:i + _CHUNK]
+        result = result * 10 ** len(chunk) + int(chunk)
+    return result
+
+
+def int_to_digits(value: int) -> str:
+    """
+    (en) Converts a non-negative int to a decimal digit string.
+    Unlike str(), this is not limited by sys.get_int_max_str_digits().
+
+    (ja) 非負の整数を10進数字の文字列に変換します。
+    str() と異なり sys.get_int_max_str_digits() の制限を受けません。
+
+    Parameters
+    ----------
+    value: int
+        A non-negative integer.
+
+    Returns
+    -------
+    str
+        The digit string without leading zeros ("0" for zero).
+    """
+    if value < _CHUNK_BASE:
+        return str(value)
+    chunks = []
+    while value >= _CHUNK_BASE:
+        value, low = divmod(value, _CHUNK_BASE)
+        chunks.append(str(low).rjust(_CHUNK, "0"))
+    chunks.append(str(value))
+    return "".join(reversed(chunks))

simple_portable_numeric-0.0.1.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: simple_portable_numeric
+Version: 0.0.1
+Summary: Arbitrary-precision decimal and rational arithmetic that gives identical results in Dart and Python.
+Author: Masahide Mori
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/MasahideMori-SimpleAppli/simple_portable_numeric
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# simple_portable_numeric
+
+(en)Japanese ver
+is [here](https://github.com/MasahideMori-SimpleAppli/simple_portable_numeric/blob/main/python/README_JA.md).  
+(ja)
+この解説の日本語版は[ここ](https://github.com/MasahideMori-SimpleAppli/simple_portable_numeric/blob/main/python/README_JA.md)
+にあります。
+
+## Overview
+
+**simple_portable_numeric is an arbitrary-precision decimal and rational arithmetic library
+that gives identical results in Dart and Python.**
+
+Both versions are built only on arbitrary-precision integers (Dart `BigInt`, Python `int`)
+and follow one shared [specification](https://github.com/MasahideMori-SimpleAppli/simple_portable_numeric/blob/main/spec/SPEC.md).
+Platform libraries such as Python's `decimal` (28 significant digits by default) are not used,
+so the number of digits, rounding and string format never differ between the languages.
+
+## Features
+
+- `PortableDecimal`: exact `+ - *` with no digit limit.
+  Division always takes an explicit scale and rounding mode.
+- `PortableRational`: exact `+ - * /`, always kept reduced.
+- Five rounding modes: `halfEven`, `halfUp`, `down`, `floor`, `ceiling`.
+- Strict and stable string format, suitable for storing values as text (e.g. in a database).
+- Equality by value (`1.50 == 1.5`), while the string keeps the scale (`"1.50"`).
+- Correctly rounded conversion to double, identical in both languages.
+- No dependencies.
+- Dart version available.  
+  → https://pub.dev/packages/simple_portable_numeric
+
+## Quick Start
+
+```python
+from simple_portable_numeric import EnumRoundingMode, PortableDecimal, PortableRational
+
+# Decimal
+a = PortableDecimal.parse("1.50")
+b = PortableDecimal.parse("2.3")
+print(a + b)  # 3.80
+print(a * b)  # 3.450
+print(a == PortableDecimal.parse("1.5"))  # True
+print(PortableDecimal.parse("1").divide(
+    PortableDecimal.parse("3"), 5, EnumRoundingMode.halfEven))  # 0.33333
+print(PortableDecimal.parse("2.5").set_scale(0, EnumRoundingMode.halfEven))  # 2
+
+# Rational
+r = PortableRational.parse("1/3") + PortableRational.parse("1/6")
+print(r)  # 1/2
+print(r.to_decimal(2, EnumRoundingMode.halfUp))  # 0.50
+print(PortableRational.parse("0.75"))  # 3/4
+
+# Conversion
+print(PortableDecimal.parse("0.1").to_rational())  # 1/10
+print(PortableRational.parse("1/3").to_float())  # 0.3333333333333333
+```
+
+## Notes
+
+- Strings must be plain notation such as `"-12.340"` or `"3/4"`.
+  Exponent notation (`"1e3"`), whitespace and non-ASCII digits are rejected.
+- `PortableDecimal` and `PortableRational` are never mixed implicitly.
+  Convert explicitly with `to_rational()` / `to_decimal(scale, rounding)`.
+- Conversion from double is not provided, because the string forms of doubles differ between languages.
+- Hash values are consistent with equality, but are not the same across languages.
+
+## Support
+
+This package is developed and maintained by me personally as an open-source project.
+For bug reports and feature requests, please use GitHub Issues.
+
+If you need **paid support, consulting, or custom development**
+(e.g. priority support, design advice, or implementation help),
+please contact my company:
+
+**SimpleAppli Inc.**
+https://simpleappli.com/en/index_en.html
+
+## About version control
+
+The C part will be changed at the time of version upgrade.
+However, versions less than 1.0.0 may change the calculation results or the string format regardless of the following rules.
+
+- Specification changes that change the calculation results or the string format.
+    - C.X.X
+- Adding methods, etc.
+    - X.C.X
+- Minor changes and bug fixes.
+    - X.X.C
+
+## License
+
+This software is released under the Apache-2.0 License, see LICENSE file.
+
+Copyright 2026 Masahide Mori
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+## Trademarks
+
+- “Dart” and “Flutter” are trademarks of Google LLC.
+  *This package is not developed or endorsed by Google LLC.*
+
+- “Python” is a trademark of the Python Software Foundation.
+  *This package is not affiliated with the Python Software Foundation.*
+
+- GitHub and the GitHub logo are trademarks of GitHub, Inc.
+  *This package is not affiliated with GitHub, Inc.*

simple_portable_numeric-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+simple_portable_numeric/__init__.py,sha256=vE_i7vY7XlgWrHM6cFAwSkt6U2ZPCj2MTlzMfIHK1O4,299
+simple_portable_numeric/enum_rounding_mode.py,sha256=g4E6t8VOVHh93t3skGNjpTemmBT7nVqEwpokTFUSFj0,640
+simple_portable_numeric/portable_decimal.py,sha256=Uu97PGvlSSTH54czeM0R6yzqQ58et-MfnQH7v_kc1sQ,11142
+simple_portable_numeric/portable_rational.py,sha256=HDuZn0uwmG4uHt9ikRnqebasgdQ-BCh0gexz8KtDr44,8924
+simple_portable_numeric/util_int_math.py,sha256=dV5Ra1WbM06M1HU6T-ca1TM4DozwvasqvcOG1N88jZs,3671
+simple_portable_numeric-0.0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+simple_portable_numeric-0.0.1.dist-info/METADATA,sha256=hfCAMWlqTYtj0vorU_1Lc6BVBaxXm02UVHxRiqAj0VY,5228
+simple_portable_numeric-0.0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+simple_portable_numeric-0.0.1.dist-info/top_level.txt,sha256=HDOOBDTyY861z8xHL0INab2vDlaRojz5qrP4QhKegoc,24
+simple_portable_numeric-0.0.1.dist-info/RECORD,,

simple_portable_numeric-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simple_portable_numeric-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

simple_portable_numeric-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+simple_portable_numeric