Skip to main content

neco_rational/
lib.rs

1#![cfg_attr(not(feature = "std"), no_std)]
2#![forbid(unsafe_code)]
3#![doc = include_str!("../README.md")]
4
5extern crate alloc;
6
7use core::cmp::Ordering;
8
9use neco_algnum::{AlgnumError, RealAlgebraic};
10use neco_bigint::{BigUint, BigintError, Dyadic, DyadicEnclosure, RawRational, ReducedRational};
11use neco_polynomial::{Enclosure, Polynomial, PolynomialFailure};
12
13#[derive(Debug, Eq, PartialEq)]
14pub struct RationalFunction {
15    numerator: Polynomial,
16    denominator: Polynomial,
17}
18
19impl RationalFunction {
20    pub fn new(numerator: Polynomial, denominator: Polynomial) -> Result<Self, RationalFailure> {
21        if is_zero_polynomial(&denominator) {
22            return Err(RationalFailure::ZeroDenominatorPolynomial);
23        }
24        Ok(Self {
25            numerator,
26            denominator,
27        })
28    }
29
30    pub fn numerator(&self) -> &Polynomial {
31        &self.numerator
32    }
33
34    pub fn denominator(&self) -> &Polynomial {
35        &self.denominator
36    }
37
38    pub fn evaluate(&self, point: &RealAlgebraic) -> Result<RealAlgebraic, RationalFailure> {
39        let denominator = self.denominator.evaluate(point)?;
40        if denominator.is_zero() {
41            return Err(RationalFailure::UndefinedDomain);
42        }
43        Ok(self.numerator.evaluate(point)?.div(&denominator)?)
44    }
45
46    pub fn evaluate_on(
47        &self,
48        domain: &Enclosure,
49        precision_bits: u32,
50    ) -> Result<Enclosure, RationalFailure> {
51        let denominator = self
52            .denominator
53            .evaluate_enclosure(domain, precision_bits)?;
54        if denominator.contains_zero() {
55            return Err(RationalFailure::DomainContainsZero);
56        }
57        let numerator = self.numerator.evaluate_enclosure(domain, precision_bits)?;
58        Ok(Enclosure::from_dyadic_enclosure(enclosure_div(
59            numerator.as_dyadic_enclosure(),
60            denominator.as_dyadic_enclosure(),
61            precision_bits,
62        )?))
63    }
64}
65
66#[derive(Debug, Eq, PartialEq)]
67pub enum RationalFailure {
68    ZeroDenominatorPolynomial,
69    UndefinedDomain,
70    DomainContainsZero,
71    Polynomial(PolynomialFailure),
72    Algebra(AlgnumError),
73    Arithmetic(BigintError),
74}
75
76impl From<PolynomialFailure> for RationalFailure {
77    fn from(error: PolynomialFailure) -> Self {
78        Self::Polynomial(error)
79    }
80}
81
82impl From<AlgnumError> for RationalFailure {
83    fn from(error: AlgnumError) -> Self {
84        Self::Algebra(error)
85    }
86}
87
88impl From<BigintError> for RationalFailure {
89    fn from(error: BigintError) -> Self {
90        Self::Arithmetic(error)
91    }
92}
93
94fn is_zero_polynomial(polynomial: &Polynomial) -> bool {
95    polynomial.degree() == 0 && polynomial.coefficients()[0].is_zero()
96}
97
98fn enclosure_div(
99    numerator: &DyadicEnclosure,
100    denominator: &DyadicEnclosure,
101    precision_bits: u32,
102) -> Result<DyadicEnclosure, RationalFailure> {
103    let candidates = [
104        dyadic_to_rational(numerator.lower())?.div(&dyadic_to_rational(denominator.lower())?)?,
105        dyadic_to_rational(numerator.lower())?.div(&dyadic_to_rational(denominator.upper())?)?,
106        dyadic_to_rational(numerator.upper())?.div(&dyadic_to_rational(denominator.lower())?)?,
107        dyadic_to_rational(numerator.upper())?.div(&dyadic_to_rational(denominator.upper())?)?,
108    ];
109    let mut lower = candidates[0].try_clone()?;
110    let mut upper = candidates[0].try_clone()?;
111    for candidate in candidates.iter().skip(1) {
112        if candidate.cmp(&lower) == Ordering::Less {
113            lower = candidate.try_clone()?;
114        }
115        if candidate.cmp(&upper) == Ordering::Greater {
116            upper = candidate.try_clone()?;
117        }
118    }
119    Ok(DyadicEnclosure::new(
120        lower.dyadic_floor(precision_bits)?,
121        upper.dyadic_ceil(precision_bits)?,
122    )?)
123}
124
125fn dyadic_to_rational(value: &Dyadic) -> Result<ReducedRational, BigintError> {
126    let denominator = BigUint::one()?.shl_bits(value.exponent() as usize)?;
127    RawRational::new(value.integer().try_clone()?, denominator)
128        .reduce()
129        .map(|reduction| reduction.into_reduced())
130}