Struct RationalFunction

Source

pub struct RationalFunction { /* private fields */ }

Expand description

A rational function represented as numerator / denominator.

Invariants:

The denominator is never the zero polynomial
The representation is kept in reduced form (gcd of numerator and denominator is 1)

Implementations§

Source §

impl RationalFunction

Source

pub fn new(numerator: Polynomial, denominator: Polynomial) -> Self

Create a new rational function from numerator and denominator.

§Arguments

numerator - The numerator polynomial
denominator - The denominator polynomial

§Panics

Panics if the denominator is the zero polynomial.

§Examples

use oxiz_math::polynomial::Polynomial;
use oxiz_math::rational_function::RationalFunction;

let num = Polynomial::from_coeffs_int(&[(1, &[(0, 1)])]); // x
let den = Polynomial::from_coeffs_int(&[(1, &[(0, 1)]), (1, &[])]); // x + 1
let rf = RationalFunction::new(num, den);

Source

pub fn from_polynomial(p: Polynomial) -> Self

Create a rational function from a polynomial (denominator = 1).

§Examples

use oxiz_math::polynomial::Polynomial;
use oxiz_math::rational_function::RationalFunction;

let p = Polynomial::from_coeffs_int(&[(1, &[(0, 2)])]); // x^2
let rf = RationalFunction::from_polynomial(p);

Source

pub fn from_constant(c: BigRational) -> Self

Create a rational function from a constant.

§Examples

use num_bigint::BigInt;
use num_rational::BigRational;
use oxiz_math::rational_function::RationalFunction;

let rf = RationalFunction::from_constant(BigRational::from_integer(BigInt::from(5)));

Source

pub fn numerator(&self) -> &Polynomial

Get the numerator.

Source

pub fn denominator(&self) -> &Polynomial

Get the denominator.

Source

pub fn is_zero(&self) -> bool

Check if the rational function is zero.

Source

pub fn is_constant(&self) -> bool

Check if the rational function is constant.

Source

pub fn eval( &self, assignment: &FxHashMap<Var, BigRational>, ) -> Option<BigRational>

Evaluate the rational function at a point.

§Arguments

assignment - Variable assignments

§Returns

The value of the rational function, or None if the denominator evaluates to zero.

§Examples

use num_bigint::BigInt;
use num_rational::BigRational;
use oxiz_math::polynomial::Polynomial;
use oxiz_math::rational_function::RationalFunction;
use rustc_hash::FxHashMap;

let num = Polynomial::from_coeffs_int(&[(1, &[(0, 1)])]); // x
let den = Polynomial::from_coeffs_int(&[(1, &[(0, 1)]), (1, &[])]); // x + 1
let rf = RationalFunction::new(num, den);

let mut assignment = FxHashMap::default();
assignment.insert(0, BigRational::from_integer(BigInt::from(2)));
let val = rf.eval(&assignment).unwrap();
assert_eq!(val, BigRational::new(BigInt::from(2), BigInt::from(3))); // 2/3

Source

pub fn derivative(&self, var: Var) -> RationalFunction

Compute the derivative of the rational function.

Uses the quotient rule: (p/q)’ = (p’q - pq’) / q^2

§Examples

use oxiz_math::polynomial::Polynomial;
use oxiz_math::rational_function::RationalFunction;

let num = Polynomial::from_coeffs_int(&[(1, &[(0, 1)])]); // x
let den = Polynomial::from_coeffs_int(&[(1, &[(0, 1)]), (1, &[])]); // x + 1
let rf = RationalFunction::new(num, den);
let derivative = rf.derivative(0);

Source

pub fn simplify(&mut self)

Simplify the rational function.

This is an alias for reducing to lowest terms.

Source

pub fn is_proper(&self) -> bool

Check if this is a proper rational function (degree of numerator < degree of denominator).

§Examples

use oxiz_math::polynomial::Polynomial;
use oxiz_math::rational_function::RationalFunction;

let num = Polynomial::from_coeffs_int(&[(1, &[(0, 1)])]); // x
let den = Polynomial::from_coeffs_int(&[(1, &[(0, 2)])]); // x^2
let rf = RationalFunction::new(num, den);
assert!(rf.is_proper());

Source

pub fn polynomial_division( &self, _var: Var, ) -> Option<(Polynomial, RationalFunction)>

Perform polynomial long division to separate improper rational functions.

For an improper rational function N(x)/D(x) where deg(N) >= deg(D), returns (Q(x), R(x)/D(x)) where N(x)/D(x) = Q(x) + R(x)/D(x) and R(x)/D(x) is proper.

§Arguments

var - The variable for univariate division

§Returns

(quotient_polynomial, proper_remainder) if the function is improper and univariate
None if the function is proper or not univariate

§Examples

use oxiz_math::polynomial::Polynomial;
use oxiz_math::rational_function::RationalFunction;

// (x^2 + 1) / x = x + 1/x
let num = Polynomial::from_coeffs_int(&[(1, &[(0, 2)]), (1, &[])]);
let den = Polynomial::from_coeffs_int(&[(1, &[(0, 1)])]);
let rf = RationalFunction::new(num, den);

let (quotient, remainder) = rf.polynomial_division(0).unwrap();
// quotient should be x, remainder should be 1/x

Source

pub fn partial_fraction_decomposition( &self, _var: Var, ) -> Option<Vec<RationalFunction>>

Compute partial fraction decomposition for simple cases.

For a proper rational function with a factored denominator of distinct linear factors, decomposes into a sum of simpler fractions.

Note: This is a simplified implementation that works for:

Proper rational functions (deg(numerator) < deg(denominator))
Univariate polynomials
Denominators that are products of distinct linear factors

For more complex cases (repeated factors, irreducible quadratics), use specialized computer algebra systems.

§Arguments

var - The variable

§Returns

Vector of simpler rational functions that sum to the original, or None if decomposition is not applicable

§Examples

use oxiz_math::polynomial::Polynomial;
use oxiz_math::rational_function::RationalFunction;

// Example: 1 / (x(x-1)) = A/x + B/(x-1)
// where A = -1, B = 1
let num = Polynomial::from_coeffs_int(&[(1, &[])]);  // 1
let den = Polynomial::from_coeffs_int(&[             // x^2 - x
    (1, &[(0, 2)]),   // x^2
    (-1, &[(0, 1)]),  // -x
]);
let rf = RationalFunction::new(num, den);

// Partial fraction decomposition (if factors are available)
// This is a placeholder - full implementation would require factorization