Struct rustnomial::Polynomial

pub struct Polynomial<N> {
    pub terms: Vec<N>,
}

Fields

terms: Vec<N>

Implementations

impl<N> Polynomial<N> where
    N: Zero + Copy, 

pub fn new(terms: Vec<N>) -> Polynomial<N>

Returns a Polynomial with the corresponding terms, in order of ax^n + bx^(n-1) + ... + cx + d

Arguments

• terms - A vector of constants, in decreasing order of degree.

Example

use rustnomial::Polynomial;
// Corresponds to 1.0x^2 + 4.0x + 4.0
let polynomial = Polynomial::new(vec![1.0, 4.0, 4.0]);

pub fn trim(&mut self)

Reduces the size of the Polynomial in memory if the leading terms are zero.

Example

use rustnomial::Polynomial;
let mut polynomial = Polynomial::new(vec![1.0, 4.0, 4.0]);
polynomial.terms = vec![0.0, 0.0, 0.0, 0.0, 1.0, 4.0, 4.0];
polynomial.trim();
assert_eq!(vec![1.0, 4.0, 4.0], polynomial.terms);

impl Polynomial<f64>

pub fn roots(self) -> Roots<f64>

Return the roots of the Polynomial.

Example

use rustnomial::{Polynomial, Roots, SizedPolynomial};
let zero = Polynomial::<f64>::zero();
assert_eq!(Roots::InfiniteRoots, zero.roots());
let constant = Polynomial::new(vec![1.]);
assert_eq!(Roots::NoRoots, constant.roots());
let monomial = Polynomial::new(vec![1.0, 0.,]);
assert_eq!(Roots::ManyRealRoots(vec![0.]), monomial.roots());
let binomial = Polynomial::new(vec![1.0, 2.0]);
assert_eq!(Roots::ManyRealRoots(vec![-2.0]), binomial.roots());
let trinomial = Polynomial::new(vec![1.0, 4.0, 4.0]);
assert_eq!(Roots::ManyRealRoots(vec![-2.0, -2.0]), trinomial.roots());
let quadnomial = Polynomial::new(vec![1.0, 6.0, 12.0, 8.0]);
assert_eq!(Roots::ManyRealRoots(vec![-2.0, -2.0, -2.0]), quadnomial.roots());

impl<N> Polynomial<N> where
    N: Mul<Output = N> + AddAssign + Copy + Zero + One, 

pub fn pow(&self, exp: usize) -> Polynomial<N>

Raises the Polynomial to the power of exp, using exponentiation by squaring.

Example

use rustnomial::Polynomial;
let polynomial = Polynomial::new(vec![1.0, 2.0]);
let polynomial_sqr = polynomial.pow(2);
let polynomial_cub = polynomial.pow(3);
assert_eq!(polynomial.clone() * polynomial.clone(), polynomial_sqr);
assert_eq!(polynomial_sqr.clone() * polynomial.clone(), polynomial_cub);

impl<N> Polynomial<N> where
    N: Copy + Zero + SubAssign + Mul<Output = N> + Div<Output = N>, 

pub fn div_mod(&self, _rhs: &Polynomial<N>) -> (Polynomial<N>, Polynomial<N>)

Divides self by the given Polynomial, and returns the quotient and remainder.

impl<N> Polynomial<N> where
    N: Copy + Zero + SubAssign + Mul<Output = N> + Div<Output = N>, 

pub fn floor_div(&self, _rhs: &Polynomial<N>) -> Polynomial<N>

Divides self by the given Polynomial, and returns the quotient.

Trait Implementations

impl<N> Add<Polynomial<N>> for Polynomial<N> where
    N: Zero + Copy + AddAssign, 

type Output = Polynomial<N>

The resulting type after applying the + operator.

pub fn add(self, _rhs: Polynomial<N>) -> Polynomial<N>

Performs the + operation.

impl<N: Copy + Zero + AddAssign> AddAssign<Polynomial<N>> for Polynomial<N>

pub fn add_assign(&mut self, _rhs: Polynomial<N>)

Performs the += operation.

impl<N: Clone> Clone for Polynomial<N>

pub fn clone(&self) -> Polynomial<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug> Debug for Polynomial<N>

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

Formats the value using the given formatter.

impl<N> Derivable<N> for Polynomial<N> where
    N: Zero + One + TryFromUsizeContinuous + Copy + MulAssign + SubAssign, 

pub fn derivative(&self) -> Polynomial<N>

Returns the derivative of the Polynomial.

Example

use rustnomial::{Polynomial, Derivable};
let polynomial = Polynomial::new(vec![4, 1, 5]);
assert_eq!(Polynomial::new(vec![8, 1]), polynomial.derivative());

Errors

Will panic if N can not losslessly encode the numbers from 0 to the degree of self.

impl<N> Display for Polynomial<N> where
    N: Zero + One + IsPositive + PartialEq + Abs + Copy + IsNegativeOne + Display, 

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

Formats the value using the given formatter.

impl<N> Div<N> for Polynomial<N> where
    N: Zero + Copy + Div<Output = N>, 

type Output = Polynomial<N>

The resulting type after applying the / operator.

pub fn div(self, _rhs: N) -> Polynomial<N>

Performs the / operation.

impl<N: Copy + DivAssign> DivAssign<N> for Polynomial<N>

pub fn div_assign(&mut self, _rhs: N)

Performs the /= operation.

impl<N> Evaluable<N> for Polynomial<N> where
    N: Zero + Copy + AddAssign + MulAssign + Mul<Output = N>, 

pub fn eval(&self, point: N) -> N

Returns the value of the Polynomial at the given point.

Example

impl<N> FreeSizePolynomial<N> for Polynomial<N> where
    N: Zero + Copy + AddAssign, 

pub fn from_terms(terms: &[(N, usize)]) -> Self

Returns a Polynomial with the corresponding terms, in order of ax^n + bx^(n-1) + ... + cx + d

Arguments

• terms - A slice of (coefficient, degree) pairs.

Example

use rustnomial::{FreeSizePolynomial, Polynomial};
// Corresponds to 1.0x^2 + 4.0x + 4.0
let polynomial = Polynomial::from_terms(&[(1.0, 2), (4.0, 1), (4.0, 0)]);
assert_eq!(Polynomial::new(vec![1., 4., 4.]), polynomial);

pub fn add_term(&mut self, coeff: N, degree: usize)

Adds the term with given coefficient and degree to self.

impl From<Polynomial<f32>> for Polynomial<f64>

pub fn from(item: Polynomial<f32>) -> Self

Performs the conversion.

impl From<Polynomial<i16>> for Polynomial<i32>

pub fn from(item: Polynomial<i16>) -> Self

Performs the conversion.

impl From<Polynomial<i16>> for Polynomial<i64>

pub fn from(item: Polynomial<i16>) -> Self

Performs the conversion.

impl From<Polynomial<i16>> for Polynomial<i128>

pub fn from(item: Polynomial<i16>) -> Self

Performs the conversion.

impl From<Polynomial<i16>> for Polynomial<f32>

pub fn from(item: Polynomial<i16>) -> Self

Performs the conversion.

impl From<Polynomial<i16>> for Polynomial<f64>

pub fn from(item: Polynomial<i16>) -> Self

Performs the conversion.

impl From<Polynomial<i32>> for Polynomial<i64>

pub fn from(item: Polynomial<i32>) -> Self

Performs the conversion.

impl From<Polynomial<i32>> for Polynomial<i128>

pub fn from(item: Polynomial<i32>) -> Self

Performs the conversion.

impl From<Polynomial<i32>> for Polynomial<f64>

pub fn from(item: Polynomial<i32>) -> Self

Performs the conversion.

impl From<Polynomial<i64>> for Polynomial<i128>

pub fn from(item: Polynomial<i64>) -> Self

Performs the conversion.

impl From<Polynomial<i8>> for Polynomial<i16>

pub fn from(item: Polynomial<i8>) -> Self

Performs the conversion.

impl From<Polynomial<i8>> for Polynomial<i32>

pub fn from(item: Polynomial<i8>) -> Self

Performs the conversion.

impl From<Polynomial<i8>> for Polynomial<i64>

pub fn from(item: Polynomial<i8>) -> Self

Performs the conversion.

impl From<Polynomial<i8>> for Polynomial<i128>

pub fn from(item: Polynomial<i8>) -> Self

Performs the conversion.

impl From<Polynomial<i8>> for Polynomial<f32>

pub fn from(item: Polynomial<i8>) -> Self

Performs the conversion.

impl From<Polynomial<i8>> for Polynomial<f64>

pub fn from(item: Polynomial<i8>) -> Self

Performs the conversion.

impl From<Polynomial<u16>> for Polynomial<u32>

pub fn from(item: Polynomial<u16>) -> Self

Performs the conversion.

impl From<Polynomial<u16>> for Polynomial<u64>

pub fn from(item: Polynomial<u16>) -> Self

Performs the conversion.

impl From<Polynomial<u16>> for Polynomial<u128>

pub fn from(item: Polynomial<u16>) -> Self

Performs the conversion.

impl From<Polynomial<u16>> for Polynomial<i32>

pub fn from(item: Polynomial<u16>) -> Self

Performs the conversion.

impl From<Polynomial<u16>> for Polynomial<i64>

pub fn from(item: Polynomial<u16>) -> Self

Performs the conversion.

impl From<Polynomial<u16>> for Polynomial<i128>

pub fn from(item: Polynomial<u16>) -> Self

Performs the conversion.

impl From<Polynomial<u16>> for Polynomial<f32>

pub fn from(item: Polynomial<u16>) -> Self

Performs the conversion.

impl From<Polynomial<u16>> for Polynomial<f64>

pub fn from(item: Polynomial<u16>) -> Self

Performs the conversion.

impl From<Polynomial<u32>> for Polynomial<u64>

pub fn from(item: Polynomial<u32>) -> Self

Performs the conversion.

impl From<Polynomial<u32>> for Polynomial<u128>

pub fn from(item: Polynomial<u32>) -> Self

Performs the conversion.

impl From<Polynomial<u32>> for Polynomial<i64>

pub fn from(item: Polynomial<u32>) -> Self

Performs the conversion.

impl From<Polynomial<u32>> for Polynomial<i128>

pub fn from(item: Polynomial<u32>) -> Self

Performs the conversion.

impl From<Polynomial<u32>> for Polynomial<f64>

pub fn from(item: Polynomial<u32>) -> Self

Performs the conversion.

impl From<Polynomial<u64>> for Polynomial<u128>

pub fn from(item: Polynomial<u64>) -> Self

Performs the conversion.

impl From<Polynomial<u64>> for Polynomial<i128>

pub fn from(item: Polynomial<u64>) -> Self

Performs the conversion.

impl From<Polynomial<u8>> for Polynomial<u16>

pub fn from(item: Polynomial<u8>) -> Self

Performs the conversion.

impl From<Polynomial<u8>> for Polynomial<u32>

pub fn from(item: Polynomial<u8>) -> Self

Performs the conversion.

impl From<Polynomial<u8>> for Polynomial<u64>

pub fn from(item: Polynomial<u8>) -> Self

Performs the conversion.

impl From<Polynomial<u8>> for Polynomial<u128>

pub fn from(item: Polynomial<u8>) -> Self

Performs the conversion.

impl From<Polynomial<u8>> for Polynomial<i16>

pub fn from(item: Polynomial<u8>) -> Self

Performs the conversion.

impl From<Polynomial<u8>> for Polynomial<i32>

pub fn from(item: Polynomial<u8>) -> Self

Performs the conversion.

impl From<Polynomial<u8>> for Polynomial<i64>

pub fn from(item: Polynomial<u8>) -> Self

Performs the conversion.

impl From<Polynomial<u8>> for Polynomial<i128>

pub fn from(item: Polynomial<u8>) -> Self

Performs the conversion.

impl From<Polynomial<u8>> for Polynomial<f32>

pub fn from(item: Polynomial<u8>) -> Self

Performs the conversion.

impl From<Polynomial<u8>> for Polynomial<f64>

pub fn from(item: Polynomial<u8>) -> Self

Performs the conversion.

impl<N> From<Vec<N, Global>> for Polynomial<N> where
    N: Copy + Zero, 

pub fn from(term_vec: Vec<N>) -> Self

Returns a SparsePolynomial with the corresponding terms, in order of ax^n + bx^(n-1) + ... + cx + d

Arguments

• term_vec - A vector of constants, in decreasing order of degree.

Example

use rustnomial::{Polynomial};
// Corresponds to 1.0x^2 + 4.0x + 4.0
let polynomial = Polynomial::from(vec![1.0, 4.0, 4.0]);
let polynomial: Polynomial<f64> = vec![1.0, 4.0, 4.0].into();

impl<N> FromStr for Polynomial<N> where
    N: Zero + One + Copy + SubAssign + AddAssign + FromStr + CanNegate, 

type Err = PolynomialFromStringError

The associated error which can be returned from parsing.

pub fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<N> Integrable<N, Polynomial<N>> for LinearBinomial<N> where
    N: Zero + Copy + DivAssign + Mul<Output = N> + MulAssign + AddAssign + Div<Output = N> + TryFromUsizeContinuous, 

pub fn integral(&self) -> Integral<N, Polynomial<N>>

Returns the integral of the LinearBinomial.

Example

use rustnomial::{LinearBinomial, Integrable, Polynomial};
let binomial = LinearBinomial::new([2.0, 0.]);
let integral = binomial.integral();
assert_eq!(&Polynomial::new(vec![1.0, 0.0, 0.0]), integral.inner());

Will panic if N can not losslessly represent 2usize.

impl<N> Integrable<N, Polynomial<N>> for Polynomial<N> where
    N: Zero + One + Copy + DivAssign + Mul<Output = N> + MulAssign + AddAssign + TryFromUsizeContinuous + SubAssign, 

pub fn integral(&self) -> Integral<N, Polynomial<N>>

Returns the integral of the Polynomial.

Example

use rustnomial::{Polynomial, Integrable};
let polynomial = Polynomial::new(vec![1.0, 2.0, 5.0]);
let integral = polynomial.integral();
assert_eq!(&Polynomial::new(vec![1.0/3.0, 1.0, 5.0, 0.0]), integral.inner());

Errors

Will panic if N can not losslessly encode the numbers from 0 to the degree of self self.

impl<N> Integrable<N, Polynomial<N>> for QuadraticTrinomial<N> where
    N: Zero + TryFromUsizeExact + Copy + DivAssign + Mul<Output = N> + MulAssign + AddAssign + Div<Output = N>, 

pub fn integral(&self) -> Integral<N, Polynomial<N>>

Returns the integral of the Monomial.

Example

use rustnomial::{QuadraticTrinomial, Integrable, Polynomial};
let trinomial = QuadraticTrinomial::new([3.0, 0., 0.]);
let integral = trinomial.integral();
assert_eq!(&Polynomial::new(vec![1.0, 0.0, 0.0, 0.0]), integral.inner());

Errors

Will panic if N can not losslessly represent 2usize or 3usize.

impl<N> Mul<&'_ Polynomial<N>> for Polynomial<N> where
    N: Mul<Output = N> + AddAssign + Copy + Zero, 

type Output = Polynomial<N>

The resulting type after applying the * operator.

pub fn mul(self, _rhs: &Polynomial<N>) -> Polynomial<N>

Performs the * operation.

impl<N> Mul<&'_ Polynomial<N>> for &Polynomial<N> where
    N: Mul<Output = N> + AddAssign + Copy + Zero, 

type Output = Polynomial<N>

The resulting type after applying the * operator.

pub fn mul(self, _rhs: &Polynomial<N>) -> Polynomial<N>

Performs the * operation.

impl<N: Zero + Copy + Mul<Output = N>> Mul<N> for Polynomial<N>

type Output = Polynomial<N>

The resulting type after applying the * operator.

pub fn mul(self, _rhs: N) -> Polynomial<N>

Performs the * operation.

impl<N> Mul<Polynomial<N>> for Polynomial<N> where
    N: Mul<Output = N> + AddAssign + Copy + Zero, 

type Output = Polynomial<N>

The resulting type after applying the * operator.

pub fn mul(self, _rhs: Polynomial<N>) -> Polynomial<N>

Performs the * operation.

impl<N> Mul<Polynomial<N>> for &Polynomial<N> where
    N: Mul<Output = N> + AddAssign + Copy + Zero, 

type Output = Polynomial<N>

The resulting type after applying the * operator.

pub fn mul(self, _rhs: Polynomial<N>) -> Polynomial<N>

Performs the * operation.

impl<N> MulAssign<&'_ Polynomial<N>> for Polynomial<N> where
    N: Mul<Output = N> + AddAssign + Copy + Zero, 

pub fn mul_assign(&mut self, _rhs: &Polynomial<N>)

Performs the *= operation.

impl<N: Copy + MulAssign> MulAssign<N> for Polynomial<N>

pub fn mul_assign(&mut self, _rhs: N)

Performs the *= operation.

impl<N> MulAssign<Polynomial<N>> for Polynomial<N> where
    N: Mul<Output = N> + AddAssign + Copy + Zero, 

pub fn mul_assign(&mut self, _rhs: Polynomial<N>)

Performs the *= operation.

impl<N> MutablePolynomial<N> for Polynomial<N> where
    N: Zero + Copy + AddAssign + SubAssign + CanNegate, 

pub fn try_add_term(
    &mut self,
    coeff: N,
    degree: usize
) -> Result<(), TryAddError>

Adds the term with given coefficient and degree to self, returning an error if the particular term can not be added to self without violating constraints.

pub fn try_sub_term(
    &mut self,
    coeff: N,
    degree: usize
) -> Result<(), TryAddError>

Subtracts the term with given coefficient and degree from self, returning an error if the particular term can not be subtracted from self without violating constraints.

impl<N> Neg for Polynomial<N> where
    N: Zero + Copy + Neg<Output = N>, 

type Output = Polynomial<N>

The resulting type after applying the - operator.

pub fn neg(self) -> Polynomial<N>

Performs the unary - operation.

impl<N> PartialEq<Polynomial<N>> for Polynomial<N> where
    N: PartialEq + Zero + Copy, 

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

Returns true if self and other have the same terms.

Example

use rustnomial::Polynomial;
let a = Polynomial::new(vec![1.0, 2.0]);
let b = Polynomial::new(vec![2.0, 2.0]);
let c = Polynomial::new(vec![1.0, 0.0]);
assert_ne!(a, b);
assert_ne!(a, c);
assert_eq!(a, b - c);

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<N> Rem<Polynomial<N>> for Polynomial<N> where
    N: Copy + Zero + SubAssign + Mul<Output = N> + Div<Output = N>, 

type Output = Polynomial<N>

The resulting type after applying the % operator.

pub fn rem(self, _rhs: Polynomial<N>) -> Polynomial<N>

Returns the remainder of dividing self by _rhs.

impl<N> RemAssign<Polynomial<N>> for Polynomial<N> where
    N: Copy + Zero + SubAssign + Mul<Output = N> + Div<Output = N>, 

pub fn rem_assign(&mut self, _rhs: Polynomial<N>)

Assign the remainder of dividing self by _rhs to self.

impl<N: Zero + Copy> Shl<i32> for Polynomial<N>

type Output = Polynomial<N>

The resulting type after applying the << operator.

pub fn shl(self, _rhs: i32) -> Polynomial<N>

Performs the << operation.

impl<N: Zero + Copy> ShlAssign<i32> for Polynomial<N>

pub fn shl_assign(&mut self, _rhs: i32)

Performs the <<= operation.

impl<N: Zero + Copy> Shr<i32> for Polynomial<N>

type Output = Polynomial<N>

The resulting type after applying the >> operator.

pub fn shr(self, _rhs: i32) -> Polynomial<N>

Performs the >> operation.

impl<N: Zero + Copy> ShrAssign<i32> for Polynomial<N>

pub fn shr_assign(&mut self, _rhs: i32)

Performs the >>= operation.

impl<N: Copy + Zero> SizedPolynomial<N> for Polynomial<N>

pub fn len(&self) -> usize

Returns the length of the Polynomial. Not equal to the number of terms.

pub fn term_with_degree(&self, degree: usize) -> Term<N>

Returns the term with the given degree from SizedPolynomial. If the term degree is larger than the actual degree, ZeroTerm will be returned. However, terms which are zero will also be returned as ZeroTerm.

pub fn degree(&self) -> Degree

Returns the degree of the Polynomial it is called on, corresponding to the largest non-zero term.

Example

use rustnomial::{SizedPolynomial, Polynomial, Degree};
let polynomial = Polynomial::new(vec![1.0, 4.0, 4.0]);
assert_eq!(Degree::Num(2), polynomial.degree());

pub fn zero() -> Polynomial<N>

Returns a Polynomial with no terms.

Example

use rustnomial::{SizedPolynomial, Polynomial};
let zero = Polynomial::<i32>::zero();
assert!(zero.is_zero());
assert!(zero.term_iter().next().is_none());
assert!(zero.terms.is_empty());

pub fn set_to_zero(&mut self)

Sets self to zero.

Example

use rustnomial::{Polynomial, SizedPolynomial};
let mut non_zero = Polynomial::from(vec![0, 1]);
assert!(!non_zero.is_zero());
non_zero.set_to_zero();
assert!(non_zero.is_zero());

pub fn term_iter(&self) -> TermIterator<'_, N> where
    Self: Sized, 

Returns an iterator for the Polynomial, yielding the coefficient and degree of each non-zero term, in descending degree order.

pub fn is_zero(&self) -> bool

Returns true if all terms are zero, and false if a non-zero term exists.

impl<N> Sub<Polynomial<N>> for Polynomial<N> where
    N: Zero + Copy + Sub<Output = N> + SubAssign + Neg<Output = N>, 

type Output = Polynomial<N>

The resulting type after applying the - operator.

pub fn sub(self, _rhs: Polynomial<N>) -> Polynomial<N>

Performs the - operation.

impl<N> Sub<Polynomial<N>> for SparsePolynomial<N> where
    N: Zero + Copy + Sub<Output = N> + SubAssign + Neg<Output = N>, 

type Output = SparsePolynomial<N>

The resulting type after applying the - operator.

pub fn sub(self, _rhs: Polynomial<N>) -> SparsePolynomial<N>

Performs the - operation.

impl<N> SubAssign<Polynomial<N>> for Polynomial<N> where
    N: Neg<Output = N> + Sub<Output = N> + SubAssign + Copy + Zero, 

pub fn sub_assign(&mut self, _rhs: Polynomial<N>)

Performs the -= operation.