| """Closed exact rational intervals and outward-exact arithmetic.""" |
| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
| from typing import Any, Iterable |
|
|
| from .rational import Q |
|
|
|
|
| @dataclass(frozen=True, slots=True) |
| class ClosedInterval: |
| lower: Q |
| upper: Q |
|
|
| def __post_init__(self) -> None: |
| lo = Q.from_value(self.lower) |
| hi = Q.from_value(self.upper) |
| if hi < lo: |
| raise ValueError(f"interval upper {hi} is below lower {lo}") |
| object.__setattr__(self, "lower", lo) |
| object.__setattr__(self, "upper", hi) |
|
|
| @classmethod |
| def point(cls, value: Any) -> "ClosedInterval": |
| q = Q.from_value(value) |
| return cls(q, q) |
|
|
| @classmethod |
| def from_value(cls, value: Any) -> "ClosedInterval": |
| if isinstance(value, cls): |
| return value |
| if isinstance(value, dict): |
| return cls(Q.from_value(value["lower"]), Q.from_value(value["upper"])) |
| if isinstance(value, (list, tuple)) and len(value) == 2: |
| return cls(Q.from_value(value[0]), Q.from_value(value[1])) |
| return cls.point(value) |
|
|
| @classmethod |
| def hull(cls, values: Iterable[Any]) -> "ClosedInterval": |
| items = [Q.from_value(v) for v in values] |
| if not items: |
| raise ValueError("cannot form interval hull of an empty sequence") |
| return cls(min(items), max(items)) |
|
|
| def to_record(self) -> dict[str, dict[str, int]]: |
| return {"lower": self.lower.to_record(), "upper": self.upper.to_record()} |
|
|
| def to_text(self) -> str: |
| return f"[{self.lower.to_text()},{self.upper.to_text()}]" |
|
|
| def width(self) -> Q: |
| return self.upper - self.lower |
|
|
| def midpoint(self) -> Q: |
| return (self.lower + self.upper) / 2 |
|
|
| def contains(self, value: Any) -> bool: |
| q = Q.from_value(value) |
| return self.lower <= q <= self.upper |
|
|
| def contains_zero(self) -> bool: |
| return self.contains(0) |
|
|
| def interior_contains_zero(self) -> bool: |
| return self.lower < 0 < self.upper |
|
|
| def is_point(self) -> bool: |
| return self.lower == self.upper |
|
|
| def sign_class(self) -> str: |
| if self.upper < 0: |
| return "negative" |
| if self.lower > 0: |
| return "positive" |
| zero = Q(0) |
| if self.lower == zero and self.upper == zero: |
| return "zero" |
| if self.lower == zero: |
| return "nonnegative" |
| if self.upper == zero: |
| return "nonpositive" |
| return "straddles-zero" |
|
|
| def excludes_zero(self) -> bool: |
| return self.upper < 0 or self.lower > 0 |
|
|
| def intersection(self, other: Any) -> "ClosedInterval | None": |
| b = ClosedInterval.from_value(other) |
| lo = max(self.lower, b.lower) |
| hi = min(self.upper, b.upper) |
| return None if hi < lo else ClosedInterval(lo, hi) |
|
|
| def subset_of(self, other: Any) -> bool: |
| b = ClosedInterval.from_value(other) |
| return b.lower <= self.lower and self.upper <= b.upper |
|
|
| def __neg__(self) -> "ClosedInterval": |
| return ClosedInterval(-self.upper, -self.lower) |
|
|
| def __add__(self, other: Any) -> "ClosedInterval": |
| b = ClosedInterval.from_value(other) |
| return ClosedInterval(self.lower + b.lower, self.upper + b.upper) |
|
|
| def __radd__(self, other: Any) -> "ClosedInterval": |
| return self + other |
|
|
| def __sub__(self, other: Any) -> "ClosedInterval": |
| return self + (-ClosedInterval.from_value(other)) |
|
|
| def __rsub__(self, other: Any) -> "ClosedInterval": |
| return ClosedInterval.from_value(other) - self |
|
|
| def __mul__(self, other: Any) -> "ClosedInterval": |
| b = ClosedInterval.from_value(other) |
| products = ( |
| self.lower * b.lower, |
| self.lower * b.upper, |
| self.upper * b.lower, |
| self.upper * b.upper, |
| ) |
| return ClosedInterval(min(products), max(products)) |
|
|
| def __rmul__(self, other: Any) -> "ClosedInterval": |
| return self * other |
|
|
| def reciprocal(self) -> "ClosedInterval": |
| if self.contains_zero(): |
| raise ZeroDivisionError("interval reciprocal is undefined across zero") |
| return ClosedInterval(1 / self.upper, 1 / self.lower) |
|
|
| def __truediv__(self, other: Any) -> "ClosedInterval": |
| return self * ClosedInterval.from_value(other).reciprocal() |
|
|
| def __str__(self) -> str: |
| return self.to_text() |
|
|
