Struct AlgebraicNumber 

pub struct AlgebraicNumber {
    pub annihilating_poly: Polynomial,
    pub interval: (RnsRational, RnsRational),
    pub channels: Basis,
}

An exact real algebraic number (Level 2).

Fields

annihilating_poly: Polynomial

An annihilating polynomial over ℚ: monic, with this number as a root.

Resultants produce an annihilating polynomial that is not necessarily minimal. AlgebraicNumber::try_minimize reduces it toward the minimal polynomial (square-free + rational-root factorization); without full factorization over ℚ this is best-effort, not guaranteed.

interval: (RnsRational, RnsRational)

Isolating interval (lo, hi) containing exactly one root of annihilating_poly.

channels: Basis

Implementations

impl AlgebraicNumber

pub fn sqrt(n: u64, channels: Basis) -> Self

The positive square root √n.

Examples found in repository

examples/float_comparison.rs (line 41)

fn main() {
    let ch = Basis::standard();
    println!("== adele-ring :: exact vs f64 ==\n");
    println!(
        "{:<16} | {:<10} | {:<22} | {:<12} | ULPs",
        "expression", "exact", "f64 result", "abs error"
    );
    println!("{}", "-".repeat(78));

    // 0.1 + 0.2 = 3/10
    let exact = RnsRational::from_fraction(1, 10, ch.clone())
        .add(&RnsRational::from_fraction(1, 5, ch.clone()));
    row("0.1 + 0.2", &exact.display(), 0.1 + 0.2, exact.to_f64());

    // 1/3 * 3 = 1
    let one = RnsRational::from_fraction(1, 3, ch.clone()).mul(&RnsRational::from_int(3, ch.clone()));
    row("1/3 * 3", &one.display(), (1.0 / 3.0) * 3.0, one.to_f64());

    // sqrt(2) * sqrt(2) = 2  (drops to Integer through the tower)
    let s2 = TowerValue::Algebraic(AlgebraicNumber::sqrt(2, ch.clone()));
    let two = s2.mul(&s2);
    let naive = 2f64.sqrt() * 2f64.sqrt();
    row("sqrt2 * sqrt2", "2", naive, two.to_f64().unwrap());

    // sin(pi) = 0  (exact identity; f64 gives ~1.2e-16)
    let sin_pi = TowerValue::Symbolic(SymbolicExpr::Pi).sin();
    row("sin(pi)", "0", std::f64::consts::PI.sin(), sin_pi.to_f64().unwrap());

    // 1/7 * 7 = 1
    let one7 = RnsRational::from_fraction(1, 7, ch.clone()).mul(&RnsRational::from_int(7, ch));
    row("1/7 * 7", &one7.display(), (1.0 / 7.0) * 7.0, one7.to_f64());

    println!("\nEvery `exact` column is bit-for-bit correct; the f64 column drifts.");
}

pub fn cbrt(n: u64, channels: Basis) -> Self

The real cube root ∛n.

pub fn from_rational(r: RnsRational) -> Self

A rational as a degree-1 algebraic number.

pub fn from_poly_root(p: Polynomial, root_index: usize, channels: Basis) -> Self

The root_index-th real root (ascending) of p.

pub fn degree(&self) -> usize

Degree of the annihilating polynomial.

pub fn try_minimize(&self) -> AlgebraicNumber

Reduce the annihilating polynomial toward the minimal polynomial by square-free + rational-root factorization over ℚ, keeping the irreducible factor whose real root matches this number. Best-effort: without full factorization, high-degree irreducible factors are returned whole.

pub fn to_rational(&self) -> Option<RnsRational>

Some(r) iff this number is actually rational (degree-1 min poly).

pub fn refine_interval(&mut self, target_width: &RnsRational)

Refine the isolating interval until its width is < target_width.

pub fn to_f64(&self) -> f64

An f64 approximation (refines internally first).

pub fn sign(&self) -> i32

Exact sign of the number: -1, 0, or +1.

pub fn neg(&self) -> Self

Additive inverse: negate the root (x -> -x in the min poly).

pub fn recip(&self) -> Self

Multiplicative inverse: reciprocal of the root (reverse the coefficients).

pub fn add(&self, other: &Self) -> Self

α + β.

pub fn mul(&self, other: &Self) -> Self

α × β.

impl AlgebraicNumber

Bridge from Level 2 to Level 3.

pub fn to_computable(&self) -> ComputableReal

Produce a ComputableReal that yields digits on demand.

Trait Implementations

impl Clone for AlgebraicNumber

fn clone(&self) -> AlgebraicNumber

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AlgebraicNumber

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.