Struct rustnomial::SparsePolynomial

pub struct SparsePolynomial<N> {
    pub terms: HashMap<usize, N>,
}

Fields

terms: HashMap<usize, N>

Implementations

impl SparsePolynomial<f64>

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

Return the roots of the SparsePolynomial.

Example

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

impl<N> SparsePolynomial<N>

pub fn new(terms: HashMap<usize, N>) -> SparsePolynomial<N>

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

pub fn from_vec(term_vec: Vec<N>) -> SparsePolynomial<N>

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::SparsePolynomial;
// Corresponds to 1.0x^2 + 4.0x + 4.0
let polynomial = SparsePolynomial::from_vec(vec![1.0, 4.0, 4.0]);

pub fn trim(&mut self)

Reduces the size of the SparsePolynomial in memory by removing zero terms.

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

pub fn borrow_mul(&self, _rhs: &SparsePolynomial<N>) -> SparsePolynomial<N>

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

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

Example

use rustnomial::SparsePolynomial;
let polynomial = SparsePolynomial::from_vec(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> SparsePolynomial<N> where
    N: Copy + Zero + Neg<Output = N> + Sub<Output = N> + SubAssign + Mul<Output = N> + Div<Output = N> + AddAssign, 

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

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

Example

use rustnomial::SparsePolynomial;
let polynomial = SparsePolynomial::from_vec(vec![1.0, 2.0]);

Trait Implementations

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

type Output = SparsePolynomial<N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<N: Copy + AddAssign> AddAssign<SparsePolynomial<N>> for SparsePolynomial<N>

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

Performs the += operation.

impl<N: Clone> Clone for SparsePolynomial<N>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug> Debug for SparsePolynomial<N>

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

Formats the value using the given formatter.

impl<N> Derivable<N> for SparsePolynomial<N> where
    N: Zero + From<u8> + Copy + Mul<Output = N>, 

fn derivative(&self) -> SparsePolynomial<N>

Returns the derivative of the SparsePolynomial.

Example

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

impl<N> Display for SparsePolynomial<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 SparsePolynomial<N> where
    N: Copy + Div<Output = N>, 

type Output = SparsePolynomial<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<N> DivAssign<N> for SparsePolynomial<N> where
    N: Copy + DivAssign, 

fn div_assign(&mut self, _rhs: N)

Performs the /= operation.

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

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

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

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

Returns a SparsePolynomial with the corresponding terms.

Arguments

• terms - A hashmap, where keys correspond to degrees and values correspond to coefficients.

Example

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

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

impl From<SparsePolynomial<f32>> for SparsePolynomial<f64>

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

Performs the conversion.

impl From<SparsePolynomial<i16>> for SparsePolynomial<i32>

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

Performs the conversion.

impl From<SparsePolynomial<i16>> for SparsePolynomial<i64>

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

Performs the conversion.

impl From<SparsePolynomial<i16>> for SparsePolynomial<i128>

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

Performs the conversion.

impl From<SparsePolynomial<i16>> for SparsePolynomial<f32>

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

Performs the conversion.

impl From<SparsePolynomial<i16>> for SparsePolynomial<f64>

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

Performs the conversion.

impl From<SparsePolynomial<i32>> for SparsePolynomial<i64>

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

Performs the conversion.

impl From<SparsePolynomial<i32>> for SparsePolynomial<i128>

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

Performs the conversion.

impl From<SparsePolynomial<i32>> for SparsePolynomial<f64>

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

Performs the conversion.

impl From<SparsePolynomial<i64>> for SparsePolynomial<i128>

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

Performs the conversion.

impl From<SparsePolynomial<i8>> for SparsePolynomial<i16>

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

Performs the conversion.

impl From<SparsePolynomial<i8>> for SparsePolynomial<i32>

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

Performs the conversion.

impl From<SparsePolynomial<i8>> for SparsePolynomial<i64>

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

Performs the conversion.

impl From<SparsePolynomial<i8>> for SparsePolynomial<i128>

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

Performs the conversion.

impl From<SparsePolynomial<i8>> for SparsePolynomial<f32>

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

Performs the conversion.

impl From<SparsePolynomial<i8>> for SparsePolynomial<f64>

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

Performs the conversion.

impl From<SparsePolynomial<u16>> for SparsePolynomial<u32>

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

Performs the conversion.

impl From<SparsePolynomial<u16>> for SparsePolynomial<u64>

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

Performs the conversion.

impl From<SparsePolynomial<u16>> for SparsePolynomial<u128>

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

Performs the conversion.

impl From<SparsePolynomial<u16>> for SparsePolynomial<i32>

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

Performs the conversion.

impl From<SparsePolynomial<u16>> for SparsePolynomial<i64>

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

Performs the conversion.

impl From<SparsePolynomial<u16>> for SparsePolynomial<i128>

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

Performs the conversion.

impl From<SparsePolynomial<u16>> for SparsePolynomial<f32>

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

Performs the conversion.

impl From<SparsePolynomial<u16>> for SparsePolynomial<f64>

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

Performs the conversion.

impl From<SparsePolynomial<u32>> for SparsePolynomial<u64>

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

Performs the conversion.

impl From<SparsePolynomial<u32>> for SparsePolynomial<u128>

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

Performs the conversion.

impl From<SparsePolynomial<u32>> for SparsePolynomial<i64>

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

Performs the conversion.

impl From<SparsePolynomial<u32>> for SparsePolynomial<i128>

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

Performs the conversion.

impl From<SparsePolynomial<u32>> for SparsePolynomial<f64>

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

Performs the conversion.

impl From<SparsePolynomial<u64>> for SparsePolynomial<u128>

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

Performs the conversion.

impl From<SparsePolynomial<u64>> for SparsePolynomial<i128>

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

Performs the conversion.

impl From<SparsePolynomial<u8>> for SparsePolynomial<u16>

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

Performs the conversion.

impl From<SparsePolynomial<u8>> for SparsePolynomial<u32>

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

Performs the conversion.

impl From<SparsePolynomial<u8>> for SparsePolynomial<u64>

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

Performs the conversion.

impl From<SparsePolynomial<u8>> for SparsePolynomial<u128>

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

Performs the conversion.

impl From<SparsePolynomial<u8>> for SparsePolynomial<i16>

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

Performs the conversion.

impl From<SparsePolynomial<u8>> for SparsePolynomial<i32>

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

Performs the conversion.

impl From<SparsePolynomial<u8>> for SparsePolynomial<i64>

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

Performs the conversion.

impl From<SparsePolynomial<u8>> for SparsePolynomial<i128>

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

Performs the conversion.

impl From<SparsePolynomial<u8>> for SparsePolynomial<f32>

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

Performs the conversion.

impl From<SparsePolynomial<u8>> for SparsePolynomial<f64>

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

Performs the conversion.

impl<N> FromStr for SparsePolynomial<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: Zero + Copy> GenericPolynomial<N> for SparsePolynomial<N>

fn zero() -> SparsePolynomial<N>

Returns a SparsePolynomial with no terms.

Example

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

fn len(&self) -> usize

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

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

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

Example

use rustnomial::{SparsePolynomial, GenericPolynomial};
let spolynomial = SparsePolynomial::from_vec(vec![1, 0, 2, 3]);
let mut iter = spolynomial.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 SparsePolynomial it is called on, corresponding to the largest non-zero term.

Example

use rustnomial::{GenericPolynomial, SparsePolynomial, Degree};
let polynomial = SparsePolynomial::from_vec(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::{SparsePolynomial, GenericPolynomial};
let zero = SparsePolynomial::from_vec(vec![0, 0]);
assert!(zero.is_zero());
let non_zero = SparsePolynomial::from_vec(vec![0, 1]);
assert!(!non_zero.is_zero());

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

type Output = SparsePolynomial<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N: Copy + Mul<Output = N>> Mul<N> for SparsePolynomial<N>

type Output = SparsePolynomial<N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = SparsePolynomial<N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

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

fn mul_assign(&mut self, _rhs: N)

Performs the *= operation.

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

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

Performs the *= operation.

impl<N> MutablePolynomial<N> for SparsePolynomial<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 SparsePolynomial<N> where
    N: Zero + Copy + Neg<Output = N>, 

type Output = SparsePolynomial<N>

The resulting type after applying the - operator.

fn neg(self) -> SparsePolynomial<N>

Performs the unary - operation.

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

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

Returns true if self has the same terms as other.

Example

use rustnomial::SparsePolynomial;
let a = SparsePolynomial::from_vec(vec![1.0, 2.0]);
let b = SparsePolynomial::from_vec(vec![2.0, 2.0]);
let c = SparsePolynomial::from_vec(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<SparsePolynomial<N>> for SparsePolynomial<N> where
    N: Copy + Zero + Neg<Output = N> + Sub<Output = N> + SubAssign + Mul<Output = N> + Div<Output = N> + AddAssign, 

type Output = SparsePolynomial<N>

The resulting type after applying the % operator.

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

Returns the remainder of dividing self by _rhs.

impl<N> RemAssign<SparsePolynomial<N>> for SparsePolynomial<N> where
    N: Copy + Zero + Neg<Output = N> + Sub<Output = N> + SubAssign + Mul<Output = N> + Div<Output = N> + AddAssign, 

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

Assign the remainder of dividing self by _rhs to self.

impl<N: Copy> Shl<i32> for SparsePolynomial<N>

type Output = SparsePolynomial<N>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<N: Copy> ShlAssign<i32> for SparsePolynomial<N>

fn shl_assign(&mut self, _rhs: i32)

Performs the <<= operation.

impl<N: Copy> Shr<i32> for SparsePolynomial<N>

type Output = SparsePolynomial<N>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<N: Copy> ShrAssign<i32> for SparsePolynomial<N>

fn shr_assign(&mut self, _rhs: i32)

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> Sub<SparsePolynomial<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: SparsePolynomial<N>) -> SparsePolynomial<N>

Performs the - operation.

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

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

Performs the -= operation.