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}