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, GenericPolynomial};
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.

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

Performs the + operation.

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

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

Performs the += operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<N> Derivable<N> for Polynomial<N> where
    N: Zero + From<u8> + Copy + MulAssign, 

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());

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

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.

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

Performs the / operation.

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

fn div_assign(&mut self, _rhs: N)

Performs the /= operation.

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

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, 

fn from_terms(terms: Vec<(N, usize)>) -> Self

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]);

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

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

type Err = PolynomialFromStringError

The associated error which can be returned from parsing.

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

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

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

fn zero() -> Polynomial<N>

Returns a Polynomial with no terms.

Example

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

fn len(&self) -> usize

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

fn nth_term(&self, index: usize) -> Term<N>

fn term_iter(&self) -> TermIterator<N>

Returns an iterator for the Polynomial, yielding the term constant and degree. Terms are iterated over in descending degree order, excluding zero terms.

Example

use rustnomial::{Polynomial, GenericPolynomial};
let polynomial = Polynomial::new(vec![1, 0, 2, 3]);
let mut iter = polynomial.term_iter();
assert_eq!(Some((1, 3)), iter.next());
assert_eq!(Some((2, 1)), iter.next());
assert_eq!(Some((3, 0)), iter.next());
assert_eq!(None, iter.next());

fn degree(&self) -> Degree

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

Example

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

fn is_zero(&self) -> bool

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

Example

use rustnomial::{GenericPolynomial, Polynomial};
let zero = Polynomial::new(vec![0, 0]);
assert!(zero.is_zero());
let non_zero = Polynomial::new(vec![0, 1]);
assert!(!non_zero.is_zero());

impl<N> Integrable<N> for Polynomial<N> where
    N: Zero + From<u8> + Copy + DivAssign, 

fn integral(&self) -> Integral<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.polynomial);

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.

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.

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.

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.

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.

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, 

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

Performs the *= operation.

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

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, 

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

Performs the *= operation.

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

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

fn set_to_zero(&mut self)

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

type Output = Polynomial<N>

The resulting type after applying the - operator.

fn neg(self) -> Polynomial<N>

Performs the unary - operation.

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

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]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.

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>, 

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.

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

Performs the << operation.

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

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.

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

Performs the >> operation.

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

fn shr_assign(&mut self, _rhs: i32)

Performs the >>= operation.

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.

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.

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, 

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

Performs the -= operation.