Struct Poly 

pub struct Poly<T: Ring> { /* private fields */ }

Generic univariate polynomial with coefficients of type T

Coefficients are stored in ascending order: coeffs[i] is the coefficient of x^i. The zero polynomial has an empty coefficient vector.

Examples

use mathhook_core::core::polynomial::poly::IntPoly;

let p = IntPoly::from_coeffs(vec![1, 2, 3]);  // 1 + 2x + 3x²
assert_eq!(p.degree(), Some(2));
assert_eq!(p.leading_coeff(), 3);

Implementations

impl<T: Ring> Poly<T>

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

Polynomial addition

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

Polynomial subtraction

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

Polynomial multiplication (schoolbook algorithm)

O(n*m) where n, m are degrees

pub fn scale(&self, c: &T) -> Self

Scalar multiplication

pub fn negate(&self) -> Self

Negation

pub fn derivative(&self) -> Self

Derivative

pub fn evaluate(&self, x: &T) -> T

Evaluate polynomial at a point using Horner’s method

Uses Horner’s method: O(n) multiplications instead of O(n²)

impl Poly<i64>

pub fn evaluate_i64(&self, x: i64) -> i64

Evaluate at integer point (IntPoly-specific optimized version)

pub fn scale_i64(&self, c: i64) -> Self

Scalar multiplication for i64 (IntPoly-specific optimized version)

pub fn derivative_i64(&self) -> Self

Derivative for IntPoly (optimized version)

impl Poly<i64>

pub fn try_from_expression(expr: &Expression, var: &Symbol) -> Option<Self>

Try to convert an Expression to IntPoly

Returns Some(IntPoly) if the expression is a univariate polynomial with integer coefficients. Returns None otherwise.

Example

use mathhook_core::{symbol, expr};
use mathhook_core::core::polynomial::poly::IntPoly;

let x = symbol!(x);
let poly = expr!((x^2) + (2*x) + 1);
if let Some(int_poly) = IntPoly::try_from_expression(&poly, &x) {
    let deriv = int_poly.derivative();
}

pub fn to_expression(&self, var: &Symbol) -> Expression

Convert IntPoly back to Expression

Example

use mathhook_core::symbol;
use mathhook_core::core::polynomial::poly::IntPoly;

let x = symbol!(x);
let p = IntPoly::from_coeffs(vec![1, 2, 3]);
let expr = p.to_expression(&x);

pub fn can_convert(expr: &Expression, var: &Symbol) -> bool

Check if an Expression can be converted to IntPoly

This is a fast check that doesn’t allocate.

impl<T: EuclideanDomain> Poly<T>

pub fn div_rem(&self, divisor: &Self) -> Result<(Self, Self), MathError>

Polynomial division with remainder

Returns (quotient, remainder) such that self = quotient * divisor + remainder and degree(remainder) < degree(divisor)

Errors

Returns MathError::DivisionByZero if divisor is zero

pub fn pseudo_div_rem( &self, divisor: &Self, ) -> Result<(Self, Self, T), MathError>

Polynomial pseudo-division

Returns (quotient, remainder, multiplier) such that: multiplier * self = quotient * divisor + remainder

This avoids fractions by multiplying by powers of the leading coefficient.

Errors

Returns MathError::DivisionByZero if divisor is zero

pub fn gcd(&self, other: &Self) -> Result<Self, MathError>

GCD using Euclidean algorithm

Returns the greatest common divisor of two polynomials. The result is made primitive (content = 1).

Errors

Returns MathError::DivisionByZero if division by zero occurs during computation

pub fn content(&self) -> T

Content: GCD of all coefficients

pub fn primitive_part(&self) -> Result<Self, MathError>

Primitive part: polynomial / content

Errors

Returns MathError::DivisionByZero if content is zero

impl Poly<i64>

pub fn is_monic(&self) -> bool

Check if polynomial is monic (leading coefficient = 1)

pub fn try_make_monic(&self) -> Option<Self>

Make polynomial monic by dividing by leading coefficient Returns None if leading coefficient doesn’t divide all coefficients

pub fn normalize(&self) -> Self

Normalize IntPoly (make leading coefficient positive)

pub fn content_i64(&self) -> i64

Content for IntPoly (optimized)

pub fn primitive_part_i64(&self) -> Result<Self, MathError>

Primitive part for IntPoly (optimized)

Errors

Returns MathError::DivisionByZero if content is zero

pub fn gcd_i64(&self, other: &Self) -> Result<Self, MathError>

GCD for IntPoly (optimized)

Errors

Returns MathError::DivisionByZero if division by zero occurs during computation

impl<T: Ring> Poly<T>

pub fn from_coeffs(coeffs: Vec<T>) -> Self

Create polynomial from coefficients (ascending order)

Arguments

• coeffs - Coefficients where coeffs[i] is coefficient of x^i

Example

use mathhook_core::core::polynomial::poly::IntPoly;

let p = IntPoly::from_coeffs(vec![1, 2, 3]);
assert_eq!(p.degree(), Some(2));

pub fn zero() -> Self

Create zero polynomial

pub fn constant(c: T) -> Self

Create constant polynomial

pub fn is_zero(&self) -> bool

Check if polynomial is zero

pub fn is_constant(&self) -> bool

Check if polynomial is constant

pub fn degree(&self) -> Option<usize>

Get polynomial degree (None for zero polynomial)

pub fn leading_coeff(&self) -> T

Get leading coefficient (zero for zero polynomial)

pub fn coeff(&self, i: usize) -> T

Get coefficient of x^i

pub fn coefficients(&self) -> &[T]

Get all coefficients

impl Poly<i64>

pub fn monomial(n: usize) -> Self

Create monomial x^n (IntPoly-specific)

pub fn term(coeff: i64, power: usize) -> Self

Create monomial c * x^n (IntPoly-specific)

Trait Implementations

impl<T: Ring> Add for &Poly<T>

type Output = Poly<T>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Poly<T>

Performs the + operation.

impl<T: Ring> Add for Poly<T>

type Output = Poly<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone + Ring> Clone for Poly<T>

fn clone(&self) -> Poly<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Ring> Debug for Poly<T>

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

Formats the value using the given formatter.

impl<T: Ring> Mul for &Poly<T>

type Output = Poly<T>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Poly<T>

Performs the * operation.

impl<T: Ring> Mul for Poly<T>

type Output = Poly<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Ring> Neg for &Poly<T>

type Output = Poly<T>

The resulting type after applying the - operator.

fn neg(self) -> Poly<T>

Performs the unary - operation.

impl<T: Ring> Neg for Poly<T>

type Output = Poly<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: PartialEq + Ring> PartialEq for Poly<T>

fn eq(&self, other: &Poly<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Ring> Sub for &Poly<T>

type Output = Poly<T>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Poly<T>

Performs the - operation.

impl<T: Ring> Sub for Poly<T>

type Output = Poly<T>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl<T: Eq + Ring> Eq for Poly<T>

impl<T: Ring> StructuralPartialEq for Poly<T>