logicaffeine_base/

hyperreal.rs

//! Hyperreal numbers generated by the program's infinitesimal `dt` — exact, ordered, decidable.
//!
//! A program that declares `Let dt be an infinitesimal.` gets a positive number smaller than every
//! positive standard number. Every hyperreal value built from `dt` with the field operations is a
//! **rational function of `dt` with real algebraic coefficients**, `N(dt)/D(dt)`, and that is how a
//! [`Hyperreal`] is held: reduced (`gcd(N, D) = 1`) with `D` *comonic* (its lowest-order nonzero
//! coefficient is 1), so equal values are structurally equal.
//!
//! The order is decided exactly by the transfer principle for real closed fields: a rational
//! function of `dt` has, for every small enough positive standard `t`, the sign of its
//! lowest-order coefficient — so `x > 0` exactly when the lowest-order coefficient of `N` is
//! positive (`D` being comonic). From the same expansion come the standard notions:
//!
//! - the **valuation** `v(x) = ord N − ord D` — positive for an infinitesimal, negative for an
//!   infinite value, zero for an appreciable one;
//! - the **standard part** — the leading coefficient when `v = 0`, zero when `v > 0`, and none at
//!   all (the value is not limited) when `v < 0`;
//! - `x ≈ y` — `x − y` is infinitesimal.
//!
//! A value prints as the exact rational function in the infinitesimal's name (`3 + 2·dt`, `1/dt`,
//! `(1 + dt)/(2 - dt)`), with rational coefficients scaled to integers when that is possible.

use crate::algebraic::Algebraic;
use crate::ordered_field::PolyOver;
use crate::numeric::{BigInt, Rational};
use std::cmp::Ordering;
use std::fmt;
use std::hash::{Hash, Hasher};

/// The highest degree one power may reach, so a single operation's work stays bounded.
pub const MAX_POWER_DEGREE: u64 = 1 << 12;

/// Why a power is refused.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum PowerError {
    /// Zero to a negative power.
    ZeroToNegative,
    /// The power's degree in the infinitesimal would pass [`MAX_POWER_DEGREE`].
    DegreeTooHigh { degree: u128 },
}

impl PowerError {
    /// The refusal, with the infinitesimal written `inf`.
    pub fn describe(&self, inf: &str) -> String {
        match self {
            PowerError::ZeroToNegative => "zero cannot be raised to a negative power".to_string(),
            PowerError::DegreeTooHigh { degree } => format!(
                "the power would have degree {degree} in {inf}; one power reaches at most degree 4,096"
            ),
        }
    }
}

impl fmt::Display for PowerError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.describe("the infinitesimal"))
    }
}

/// Refuse the `k`-th power of a value of degree `degree` when it would pass [`MAX_POWER_DEGREE`];
/// a standard value has no degree to bound.
pub(crate) fn check_power_degree(degree: usize, k: u64) -> Result<(), PowerError> {
    let reach = degree as u128 * u128::from(k);
    if reach > u128::from(MAX_POWER_DEGREE) {
        return Err(PowerError::DegreeTooHigh { degree: reach });
    }
    Ok(())
}

/// A polynomial in `dt` with real algebraic coefficients, little-endian, no trailing zero.
type APoly = PolyOver<Algebraic>;

/// A hyperreal number generated by the infinitesimal. See the module documentation.
#[derive(Clone, Debug)]
pub struct Hyperreal {
    num: APoly,
    den: APoly,
}

impl Hyperreal {
    /// Reduce `num/den` and make `den` comonic.
    fn make(num: APoly, den: APoly) -> Hyperreal {
        if num.is_zero() {
            return Hyperreal {
                num,
                den: APoly::one(),
            };
        }
        if den.degree() == Some(0) {
            let inv = den.c[0].recip().expect("the denominator is nonzero");
            return Hyperreal {
                num: num.scale(&inv),
                den: APoly::one(),
            };
        }
        let g = num.gcd(&den);
        let num = num.div_rem(&g).0;
        let den = den.div_rem(&g).0;
        let low = den.coeff(den.order().expect("the denominator is nonzero"));
        let inv = low.recip().expect("nonzero");
        Hyperreal {
            num: num.scale(&inv),
            den: den.scale(&inv),
        }
    }

    /// `num/den` in its one form.
    pub(crate) fn from_parts(num: APoly, den: APoly) -> Hyperreal {
        Self::make(num, den)
    }

    /// The reduced numerator and the comonic denominator.
    pub(crate) fn parts(&self) -> (&APoly, &APoly) {
        (&self.num, &self.den)
    }

    /// The infinitesimal itself.
    pub fn dt() -> Hyperreal {
        Hyperreal {
            num: APoly::from(vec![Algebraic::from_i64(0), Algebraic::from_i64(1)]),
            den: APoly::one(),
        }
    }

    pub fn from_algebraic(a: Algebraic) -> Hyperreal {
        Hyperreal {
            num: APoly::constant(a),
            den: APoly::one(),
        }
    }

    pub fn from_rational(r: Rational) -> Hyperreal {
        Self::from_algebraic(Algebraic::from_rational(r))
    }

    pub fn from_i64(n: i64) -> Hyperreal {
        Self::from_algebraic(Algebraic::from_i64(n))
    }

    /// `Σ cᵢ·(1/dt)^i` for rational `c` (little-endian), written directly as
    /// `(Σ cᵢ·dt^(d−i)) / dt^d`: with the top coefficient nonzero the numerator has a nonzero
    /// constant term, so the fraction is already in lowest terms and `dt^d` is comonic — no
    /// polynomial gcd at any degree.
    pub fn from_reciprocal_powers(c: &[Rational]) -> Hyperreal {
        let Some(d) = c.iter().rposition(|x| !x.is_zero()) else {
            return Self::from_i64(0);
        };
        let num = APoly::from((0..=d).map(|j| Algebraic::from_rational(c[d - j].clone())).collect());
        let mut den = vec![Algebraic::from_i64(0); d + 1];
        den[d] = Algebraic::from_i64(1);
        Hyperreal {
            num,
            den: APoly::from(den),
        }
    }

    pub fn is_zero(&self) -> bool {
        self.num.is_zero()
    }

    pub fn add(&self, o: &Hyperreal) -> Hyperreal {
        if self.den == o.den {
            return Self::make(self.num.add(&o.num), self.den.clone());
        }
        Self::make(
            self.num.mul(&o.den).add(&o.num.mul(&self.den)),
            self.den.mul(&o.den),
        )
    }

    pub fn neg(&self) -> Hyperreal {
        Hyperreal {
            num: self.num.neg(),
            den: self.den.clone(),
        }
    }

    pub fn sub(&self, o: &Hyperreal) -> Hyperreal {
        self.add(&o.neg())
    }

    pub fn mul(&self, o: &Hyperreal) -> Hyperreal {
        Self::make(self.num.mul(&o.num), self.den.mul(&o.den))
    }

    pub fn recip(&self) -> Option<Hyperreal> {
        if self.is_zero() {
            return None;
        }
        Some(Self::make(self.den.clone(), self.num.clone()))
    }

    pub fn div(&self, o: &Hyperreal) -> Option<Hyperreal> {
        Some(self.mul(&o.recip()?))
    }

    /// The rational `c` with `self = Σ cᵢ·(1/dt)^i`, when the value is a polynomial in `1/dt`
    /// over the rationals; `None` for a positive power of `dt`, an irrational coefficient, or a
    /// denominator that is not a power of `dt`. The inverse of
    /// [`Hyperreal::from_reciprocal_powers`].
    pub fn as_reciprocal_powers(&self) -> Option<Vec<Rational>> {
        if self.num.is_zero() {
            return Some(Vec::new());
        }
        let d = self.den.degree()?;
        if self.den.order() != Some(d) || self.num.degree()? > d {
            return None;
        }
        (0..=d).map(|i| self.num.coeff(d - i).to_rational()).collect()
    }

    /// The principal part of the Laurent expansion at `dt = 0` and the limited rest: the
    /// coefficient of `(1/dt)^j` at index `j − 1` for each `j` up to the pole's order, and
    /// `self − Σ c_j·(1/dt)^j` exactly. Writing `self = dt^(−k)·N/U` with `U(0) ≠ 0`, the
    /// coefficients are the first `k` terms of the power series `N/U`.
    pub fn principal_part(&self) -> (Vec<Algebraic>, Hyperreal) {
        let k = match self.valuation() {
            Some(v) if v < 0 => (-v) as usize,
            _ => return (Vec::new(), self.clone()),
        };
        let numerator = &self.num.c[self.num.order().expect("a pole is nonzero")..];
        let unit = &self.den.c[self.den.order().expect("the denominator is nonzero")..];
        let unit_inv = unit[0].recip().expect("the unit's constant term is nonzero");
        let zero = Algebraic::from_i64(0);
        let mut series: Vec<Algebraic> = Vec::with_capacity(k);
        for i in 0..k {
            let mut acc = numerator.get(i).cloned().unwrap_or_else(|| zero.clone());
            for j in 1..=i {
                if let Some(u) = unit.get(j) {
                    acc = acc.sub(&u.mul(&series[i - j]));
                }
            }
            series.push(acc.mul(&unit_inv));
        }
        let mut pole = vec![zero; k + 1];
        pole[k] = Algebraic::from_i64(1);
        let principal_value = Self::make(APoly::from(series.clone()), APoly::from(pole));
        let rest = self.sub(&principal_value);
        let coefficients = (1..=k).map(|j| series[k - j].clone()).collect();
        (coefficients, rest)
    }

    /// The coefficients of a polynomial in `dt`, lowest power first, when the value is one.
    pub fn as_dt_polynomial(&self) -> Option<Vec<Algebraic>> {
        (self.den == APoly::one()).then(|| self.num.c.clone())
    }

    /// The coefficient of `dt^k` in the Taylor series of a limited value at `dt = 0`. A limited
    /// value in lowest terms has `den(0) = 1`, so `s_k = num_k − Σ_{j=1}^{k} den_j·s_{k−j}`.
    pub fn taylor_coefficient(&self, k: usize) -> Algebraic {
        debug_assert!(self.is_limited(), "a Taylor series is of a limited value");
        let mut s: Vec<Algebraic> = Vec::with_capacity(k + 1);
        for i in 0..=k {
            let mut acc = self.num.coeff(i);
            for j in 1..=i {
                let d = self.den.coeff(j);
                if !d.is_zero() {
                    acc = acc.sub(&d.mul(&s[i - j]));
                }
            }
            s.push(acc);
        }
        s.pop().expect("k + 1 terms")
    }

    /// `self = outside^n · inside`, where every polynomial factor of `inside`'s numerator and
    /// denominator appears fewer than `n` times (Yun's squarefree decomposition takes the `n`-th powers
    /// out) and `inside`'s constant is taken out only when it is an `n`-th power: with rational
    /// coefficients the factors left inside are primitive integer polynomials with a positive
    /// lowest-order coefficient and the constant is the rest, otherwise they are monic and the constant's
    /// `n`-th root — real, the positive one for even `n` — goes outside. `None` for zero, and for an even
    /// `n` of a negative value.
    pub fn root_split(&self, n: u32) -> Option<(Hyperreal, Hyperreal)> {
        if self.is_zero() || (n % 2 == 0 && self.signum() < 0) {
            return None;
        }
        let (num_lc, num_parts) = self.num.squarefree_parts();
        let (den_lc, den_parts) = self.den.squarefree_parts();
        let power = |parts: &[(APoly, usize)], take: &dyn Fn(usize) -> usize| {
            parts
                .iter()
                .fold(APoly::one(), |acc, (a, i)| (0..take(*i)).fold(acc, |acc, _| acc.mul(a)))
        };
        let n = n as usize;
        let out_num = power(&num_parts, &|i| i / n);
        let out_den = power(&den_parts, &|i| i / n);
        let mut in_num = power(&num_parts, &|i| i % n);
        let mut in_den = power(&den_parts, &|i| i % n);
        let mut constant = num_lc.div(&den_lc)?;
        let rational = in_num.c.iter().chain(&in_den.c).all(|a| a.to_rational().is_some())
            && constant.to_rational().is_some();
        if rational {
            let (sn, sd) = (primitive_scale(&in_num), primitive_scale(&in_den));
            in_num = in_num.scale(&sn);
            in_den = in_den.scale(&sd);
            constant = constant.div(&sn)?.mul(&sd);
        } else {
            let ln = in_num.coeff(in_num.order().unwrap_or(0));
            let ld = in_den.coeff(in_den.order().unwrap_or(0));
            in_num = in_num.scale(&ln.recip()?);
            in_den = in_den.scale(&ld.recip()?);
            constant = constant.mul(&ln).div(&ld)?;
        }
        let root = constant.nth_root(n as u32).filter(|r| !rational || r.to_rational().is_some());
        let (outside_constant, inside_constant) = match root {
            Some(r) => (r, Algebraic::from_i64(1)),
            None => (Algebraic::from_i64(1), constant),
        };
        let outside = Self::make(out_num.scale(&outside_constant), out_den);
        let inside = Self::make(in_num.scale(&inside_constant), in_den);
        Some((outside, inside))
    }

    /// Whether the numerator is a constant: the value is a constant over a polynomial.
    pub fn numerator_is_constant(&self) -> bool {
        self.num.degree().unwrap_or(0) == 0
    }

    /// The degrees of the reduced numerator and denominator; `(0, 0)` for zero.
    pub fn degrees(&self) -> (usize, usize) {
        (self.num.degree().unwrap_or(0), self.den.degree().unwrap_or(0))
    }

    /// `max(deg num, deg den)`: how far the value reaches in `dt`.
    pub fn degree(&self) -> usize {
        self.num.degree().unwrap_or(0).max(self.den.degree().unwrap_or(0))
    }

    /// `self^k`, refused for zero to a negative power or a degree past [`MAX_POWER_DEGREE`].
    pub fn pow(&self, k: i32) -> Result<Hyperreal, PowerError> {
        check_power_degree(self.degree(), u64::from(k.unsigned_abs()))?;
        let mut base = if k < 0 {
            self.recip().ok_or(PowerError::ZeroToNegative)?
        } else {
            self.clone()
        };
        let mut acc = Self::from_i64(1);
        let mut e = k.unsigned_abs();
        while e > 0 {
            if e & 1 == 1 {
                acc = acc.mul(&base);
            }
            e >>= 1;
            if e > 0 {
                base = base.mul(&base);
            }
        }
        Ok(acc)
    }

    /// `−1`, `0` or `1`: the sign of the lowest-order coefficient of the numerator.
    pub fn signum(&self) -> i32 {
        match self.num.order() {
            None => 0,
            Some(i) => self.num.c[i].signum(),
        }
    }

    /// The standard value, when the value has no infinitesimal part at all.
    pub fn as_standard(&self) -> Option<Algebraic> {
        if self.den != APoly::one() || self.num.c.len() > 1 {
            return None;
        }
        Some(self.num.coeff(0))
    }

    /// `ord N − ord D`; `None` for zero.
    pub fn valuation(&self) -> Option<i64> {
        let n = self.num.order()? as i64;
        let d = self.den.order().expect("the denominator is nonzero") as i64;
        Some(n - d)
    }

    /// The coefficient of the leading power of `dt`.
    pub fn leading_coefficient(&self) -> Option<Algebraic> {
        Some(self.num.c[self.num.order()?].clone())
    }

    pub fn is_infinitesimal(&self) -> bool {
        self.valuation().is_none_or(|v| v > 0)
    }

    pub fn is_limited(&self) -> bool {
        self.valuation().is_none_or(|v| v >= 0)
    }

    /// The standard real infinitely close to a limited value; `None` for an infinite one.
    pub fn standard_part(&self) -> Option<Algebraic> {
        match self.valuation() {
            None => Some(Algebraic::from_i64(0)),
            Some(v) if v > 0 => Some(Algebraic::from_i64(0)),
            Some(0) => self.leading_coefficient(),
            Some(_) => None,
        }
    }

    pub fn infinitely_close(&self, o: &Hyperreal) -> bool {
        self.sub(o).is_infinitesimal()
    }

    /// The value at the standard point `dt = t`; `None` at a pole.
    pub fn eval_at(&self, t: &Rational) -> Option<Algebraic> {
        let t = Algebraic::from_rational(t.clone());
        self.num.eval(&t).div(&self.den.eval(&t))
    }

    /// `c·dt^k`, for any integer `k`.
    pub fn monomial(c: Algebraic, k: i64) -> Hyperreal {
        let zero = || Algebraic::from_i64(0);
        let power = |n: usize| {
            let mut p = vec![zero(); n + 1];
            p[n] = Algebraic::from_i64(1);
            APoly::from(p)
        };
        if c.is_zero() {
            return Self::from_i64(0);
        }
        if k >= 0 {
            Hyperreal {
                num: power(k as usize).scale(&c),
                den: APoly::one(),
            }
        } else {
            Hyperreal {
                num: APoly::constant(c),
                den: power(k.unsigned_abs() as usize),
            }
        }
    }

    /// The same function of `dt^m`: `dt` replaced by `dt^m`, which keeps a reduced fraction reduced
    /// and a comonic denominator comonic.
    pub fn ramify(&self, m: u32) -> Hyperreal {
        let spread = |p: &APoly| {
            let mut c = vec![Algebraic::from_i64(0); p.c.len().saturating_sub(1) * m as usize + 1];
            for (i, a) in p.c.iter().enumerate() {
                c[i * m as usize] = a.clone();
            }
            APoly::from(c)
        };
        Hyperreal {
            num: spread(&self.num),
            den: spread(&self.den),
        }
    }

    /// The function `r` with `self = r(dt^m)`, when every power of `dt` the value holds is a
    /// multiple of `m`; `None` otherwise.
    pub fn unramify(&self, m: u32) -> Option<Hyperreal> {
        let gather = |p: &APoly| -> Option<APoly> {
            let mut c = Vec::new();
            for (i, a) in p.c.iter().enumerate() {
                if i % m as usize == 0 {
                    c.push(a.clone());
                } else if !a.is_zero() {
                    return None;
                }
            }
            Some(APoly::from(c))
        };
        Some(Hyperreal {
            num: gather(&self.num)?,
            den: gather(&self.den)?,
        })
    }

    /// The coefficient of `dt^k` in the Laurent expansion at `dt = 0`.
    pub fn laurent_coefficient(&self, k: i64) -> Algebraic {
        let (principal, rest) = self.principal_part();
        if k < 0 {
            let j = k.unsigned_abs() as usize;
            return principal.get(j - 1).cloned().unwrap_or_else(|| Algebraic::from_i64(0));
        }
        rest.taylor_coefficient(k as usize)
    }

    /// The rational function of numerator degree at most `l` and denominator degree at most `m`,
    /// denominator nonzero at 0, whose expansion at 0 begins with `series` (its first `l + m + 1`
    /// coefficients), by the extended Euclidean algorithm on `dt^(l+m+1)` and the truncated series;
    /// `None` when no such function exists.
    pub fn pade(series: &[Algebraic], l: usize, m: usize) -> Option<Hyperreal> {
        let n = l + m + 1;
        let mut top = vec![Algebraic::from_i64(0); n + 1];
        top[n] = Algebraic::from_i64(1);
        let truncated: Vec<Algebraic> = (0..n)
            .map(|i| series.get(i).cloned().unwrap_or_else(|| Algebraic::from_i64(0)))
            .collect();
        let (mut r0, mut r1) = (APoly::from(top), APoly::from(truncated));
        let (mut t0, mut t1) = (APoly::zero(), APoly::one());
        while r1.degree().is_some_and(|d| d > l) {
            let (q, r) = r0.div_rem(&r1);
            let t = t0.add(&q.mul(&t1).neg());
            r0 = std::mem::replace(&mut r1, r);
            t0 = std::mem::replace(&mut t1, t);
        }
        if t1.degree().unwrap_or(0) > m || t1.coeff(0).is_zero() {
            return None;
        }
        Some(Self::make(r1, t1))
    }

    /// The exact rational function with the infinitesimal written as `name`.
    pub fn render(&self, name: &str) -> String {
        self.render_powers(&|k| match k {
            1 => name.to_string(),
            k => format!("{name}^{k}"),
        })
    }

    /// The exact rational function with the infinitesimal's `k`-th power written `power(k)`, for
    /// `k ≥ 1`.
    pub fn render_powers(&self, power: &dyn Fn(usize) -> String) -> String {
        if self.den == APoly::one() {
            return poly_text(&self.num, power);
        }
        let (num, den) = self.display_parts();
        let terms = |p: &APoly| p.c.iter().filter(|a| !a.is_zero()).count();
        let numerator = poly_text(&num, power);
        let numerator = if terms(&num) > 1 { format!("({numerator})") } else { numerator };
        let denominator = poly_text(&den, power);
        let denominator = if terms(&den) > 1 || denominator.contains('·') {
            format!("({denominator})")
        } else {
            denominator
        };
        format!("{numerator}/{denominator}")
    }

    /// The numerator and denominator the value prints as: scaled to coprime integers, the
    /// denominator's lowest coefficient positive, when every coefficient is rational; the comonic form
    /// otherwise.
    pub(crate) fn display_fraction(&self) -> (APoly, APoly) {
        self.display_parts()
    }

    /// Numerator and denominator scaled to coprime integers (denominator's lowest coefficient
    /// positive) when every coefficient is rational; the comonic form otherwise.
    fn display_parts(&self) -> (APoly, APoly) {
        let all: Vec<&Algebraic> = self.num.c.iter().chain(self.den.c.iter()).collect();
        let rationals: Option<Vec<Rational>> = all.iter().map(|a| a.to_rational()).collect();
        let Some(rs) = rationals else {
            return (self.num.clone(), self.den.clone());
        };
        let lcm = rs.iter().fold(BigInt::from_i64(1), |l, r| {
            let d = r.denominator();
            let g = l.gcd(d);
            l.div_rem(&g).expect("nonzero").0.mul(d)
        });
        let ints: Vec<BigInt> = rs
            .iter()
            .map(|r| {
                r.numerator()
                    .mul(&lcm.div_rem(r.denominator()).expect("nonzero").0)
            })
            .collect();
        let g = ints.iter().fold(BigInt::zero(), |g, x| g.gcd(x));
        let k = Algebraic::from_rational(
            Rational::new(lcm, if g.is_zero() { BigInt::from_i64(1) } else { g }).expect("nonzero"),
        );
        (self.num.scale(&k), self.den.scale(&k))
    }
}

/// The rational `k` that makes `p·k` a primitive integer polynomial with a positive lowest-order
/// coefficient, for `p` with rational coefficients.
fn primitive_scale(p: &APoly) -> Algebraic {
    let rs: Vec<Rational> = p.c.iter().map(|a| a.to_rational().expect("rational coefficients")).collect();
    let lcm = rs.iter().fold(BigInt::from_i64(1), |l, r| {
        let d = r.denominator();
        let g = l.gcd(d);
        l.div_rem(&g).expect("nonzero").0.mul(d)
    });
    let ints: Vec<BigInt> = rs
        .iter()
        .map(|r| r.numerator().mul(&lcm.div_rem(r.denominator()).expect("nonzero").0))
        .collect();
    let g = ints.iter().fold(BigInt::zero(), |g, x| g.gcd(x));
    let low_negative = ints.iter().find(|x| !x.is_zero()).is_some_and(|x| x.is_negative());
    let g = if low_negative { g.negated() } else { g };
    Algebraic::from_rational(Rational::new(lcm, if g.is_zero() { BigInt::from_i64(1) } else { g }).expect("nonzero"))
}

/// `c₀ + c₁·dt + c₂·dt^2 + …` in ascending powers, signs between the terms, the `k`-th power of
/// the infinitesimal written `power(k)`.
fn poly_text(p: &APoly, power: &dyn Fn(usize) -> String) -> String {
    if p.is_zero() {
        return "0".to_string();
    }
    let mut out = String::new();
    let mut first = true;
    for (i, a) in p.c.iter().enumerate() {
        if a.is_zero() {
            continue;
        }
        let negative = a.signum() < 0;
        let magnitude = if negative { a.neg() } else { a.clone() };
        let power = if i == 0 { String::new() } else { power(i) };
        let body = if i == 0 {
            magnitude.to_string()
        } else if magnitude == Algebraic::from_i64(1) {
            power
        } else {
            let m = magnitude.to_string();
            if m.contains(' ') || m.contains('/') {
                format!("({m})·{power}")
            } else {
                format!("{m}·{power}")
            }
        };
        match (first, negative) {
            (true, true) => out.push_str(&format!("-{body}")),
            (true, false) => out.push_str(&body),
            (false, true) => out.push_str(&format!(" - {body}")),
            (false, false) => out.push_str(&format!(" + {body}")),
        }
        first = false;
    }
    out
}

impl PartialEq for Hyperreal {
    fn eq(&self, o: &Self) -> bool {
        self.num == o.num && self.den == o.den
    }
}

impl Eq for Hyperreal {}

impl Hash for Hyperreal {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.num.hash(state);
        self.den.hash(state);
    }
}

impl Ord for Hyperreal {
    fn cmp(&self, o: &Self) -> Ordering {
        match self.sub(o).signum() {
            -1 => Ordering::Less,
            0 => Ordering::Equal,
            _ => Ordering::Greater,
        }
    }
}

impl PartialOrd for Hyperreal {
    fn partial_cmp(&self, o: &Self) -> Option<Ordering> {
        Some(self.cmp(o))
    }
}

impl fmt::Display for Hyperreal {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.render("dt"))
    }
}

impl crate::exact_codec::ExactCodec for Hyperreal {
    /// The reduced numerator's coefficients, then the comonic denominator's, lowest power first.
    fn write(&self, out: &mut Vec<u8>) {
        crate::exact_codec::write_list(&self.num.c, out);
        crate::exact_codec::write_list(&self.den.c, out);
    }

    fn read(buf: &[u8], pos: &mut usize) -> Option<Self> {
        let num = APoly::from(crate::exact_codec::read_list(buf, pos)?);
        let den = APoly::from(crate::exact_codec::read_list(buf, pos)?);
        if den.is_zero() {
            return None;
        }
        Some(Hyperreal::make(num, den))
    }
}

#[cfg(test)]
#[path = "../../logicaffeine_tests/unit/logicaffeine_base/hyperreal/tests.rs"]
mod tests;