Struct series::poly::Polynomial

pub struct Polynomial<Var, C: Coeff> { /* fields omitted */ }

Laurent polynomial in a single variable

Methods

impl<Var, C: Coeff> Polynomial<Var, C>

pub fn new(var: Var, min_pow: isize, coeffs: Vec<C>) -> Polynomial<Var, C>

Create a new Laurent polynomial

Example

This creates a Laurent polynomial in the variable "x", starting at "x"^-1 with coefficients 1, 2, 3. In other words, the polynomial x^-1 + 2 + 3*x.

let p = series::Polynomial::new("x", -1, vec!(1,2,3));

pub fn var(&self) -> &Var

Get the polynomial variable

Example

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert_eq!(p.var(), &"x");

pub fn coeff(&self, pow: isize) -> &C

Get the coefficient of the polynomial variable to the given power.

Example

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert_eq!(p.coeff(-5), &0);
assert_eq!(p.coeff(-2), &0);
assert_eq!(p.coeff(-1), &1);
assert_eq!(p.coeff(0), &2);
assert_eq!(p.coeff(1), &3);
assert_eq!(p.coeff(2), &0);
assert_eq!(p.coeff(5), &0);

pub fn min_pow(&self) -> Option<isize>

Get the leading power of the polynomial variable

For vanishing polynomials None is returned

Example

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert_eq!(p.min_pow(), Some(-1));
let p = series::Polynomial::new("x", -1, vec![0]);
assert_eq!(p.min_pow(), None);

pub fn max_pow(&self) -> Option<isize>

Get the highest power of the polynomial variable

For vanishing polynomials None is returned

Example

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert_eq!(p.max_pow(), Some(1));
let p = series::Polynomial::new("x", -1, vec![0]);
assert_eq!(p.max_pow(), None);

pub fn len(&self) -> usize

Get the difference between the highest and the lowest power of the polynomial variable

Example

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert_eq!(p.len(), 3);

pub fn is_empty(&self) -> bool

Check if the polynomial is zero

Example

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert!(!p.is_empty());

let p = series::Polynomial::new("x", -1, vec!(0));
assert!(p.is_empty());

pub fn iter(&self) -> Iter<C>

Iterator over the polynomial powers and coefficients.

Example

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
let mut iter = p.iter();
assert_eq!(iter.next(), Some((-1, &1)));
assert_eq!(iter.next(), Some((0, &2)));
assert_eq!(iter.next(), Some((1, &3)));
assert_eq!(iter.next(), None);

pub fn cutoff_at(self, cutoff_pow: isize) -> Series<Var, C>

Turn a polynomial into a series with the given cutoff

Example

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
let s = series::Series::with_cutoff("x", -1, 5, vec!(1,2,3));
assert_eq!(p.cutoff_at(5), s);

Trait Implementations

impl<Var: Clone, C: Coeff + Clone, Rhs> Add<Rhs> for Polynomial<Var, C> where
    Polynomial<Var, C>: AddAssign<Rhs>, 

type Output = Polynomial<Var, C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, Var, C: Coeff, T> Add<T> for &'a Polynomial<Var, C> where
    PolynomialSlice<'a, Var, C>: Add<T, Output = Polynomial<Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, Var, C: Coeff> AddAssign<&'a C> for Polynomial<Var, C> where
    Polynomial<Var, C>: AddAssign,
    C: Clone + AddAssign<&'a C>, 

fn add_assign(&mut self, other: &'a C)

Performs the += operation.

impl<'a, Var: PartialEq + Debug, C: Coeff + Clone> AddAssign<&'a Polynomial<Var, C>> for Polynomial<Var, C> where
    C: AddAssign<&'c C>, 

fn add_assign(&mut self, other: &'a Polynomial<Var, C>)

Set p = p + q for two Laurent polynomials p and q

Example

use series::Polynomial;
let mut p = Polynomial::new("x", -3, vec!(1.,0.,-3.));
let q = Polynomial::new("x", -1, vec!(3., 4., 5.));
let res = Polynomial::new("x", -3, vec!(1.,0.,0.,4.,5.));
p += &q;
assert_eq!(res, p);

Panics

Panics if the polynomials have different expansion variables.

impl<Var, C: Coeff> AddAssign<C> for Polynomial<Var, C> where
    Polynomial<Var, C>: AddAssign<&'c C>, 

fn add_assign(&mut self, other: C)

Performs the += operation.

impl<Var, C: Coeff> AddAssign<Polynomial<Var, C>> for Polynomial<Var, C> where
    C: AddAssign<&'c C>,
    Var: PartialEq + Debug,
    C: Clone + AddAssign, 

fn add_assign(&mut self, other: Polynomial<Var, C>)

Set p = p + q for two polynomial p and q

Example

use series::Polynomial;
let mut p = Polynomial::new("x", -3, vec!(1.,0.,-3.));
let q = Polynomial::new("x", -1, vec!(3., 4., 5.));
let res = Polynomial::new("x", -3, vec!(1.,0.,0.,4.,5.));
p += q;
assert_eq!(res, p);

Panics

Panics if the polynomials have different expansion variables.

impl<'a, Var: PartialEq + Debug, C: Coeff + Clone> AddAssign<PolynomialSlice<'a, Var, C>> for Polynomial<Var, C> where
    C: AddAssign<&'c C>, 

fn add_assign(&mut self, other: PolynomialSlice<'a, Var, C>)

Performs the += operation.

impl<'a, Var: 'a, C: 'a + Coeff> AsSlice<'a, Range<isize>> for Polynomial<Var, C>

type Output = PolynomialSlice<'a, Var, C>

fn as_slice(&'a self, r: Range<isize>) -> Self::Output

impl<'a, Var: 'a, C: 'a + Coeff> AsSlice<'a, RangeFrom<isize>> for Polynomial<Var, C>

type Output = PolynomialSlice<'a, Var, C>

fn as_slice(&'a self, r: RangeFrom<isize>) -> Self::Output

impl<'a, Var: 'a, C: 'a + Coeff> AsSlice<'a, RangeFull> for Polynomial<Var, C>

type Output = PolynomialSlice<'a, Var, C>

fn as_slice(&'a self, r: RangeFull) -> Self::Output

impl<'a, Var: 'a, C: 'a + Coeff> AsSlice<'a, RangeInclusive<isize>> for Polynomial<Var, C>

type Output = PolynomialSlice<'a, Var, C>

fn as_slice(&'a self, r: RangeInclusive<isize>) -> Self::Output

impl<'a, Var: 'a, C: 'a + Coeff> AsSlice<'a, RangeTo<isize>> for Polynomial<Var, C>

type Output = PolynomialSlice<'a, Var, C>

fn as_slice(&'a self, r: RangeTo<isize>) -> Self::Output

impl<'a, Var: 'a, C: 'a + Coeff> AsSlice<'a, RangeToInclusive<isize>> for Polynomial<Var, C>

type Output = PolynomialSlice<'a, Var, C>

fn as_slice(&'a self, r: RangeToInclusive<isize>) -> Self::Output

impl<Var: Clone, C: Clone + Coeff> Clone for Polynomial<Var, C>

fn clone(&self) -> Polynomial<Var, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Var: Debug, C: Debug + Coeff> Debug for Polynomial<Var, C>

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

Formats the value using the given formatter.

impl<Var: Display, C: Coeff + Display> Display for Polynomial<Var, C>

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

Formats the value using the given formatter.

impl<'a, Var, C: Coeff> Div<&'a C> for Polynomial<Var, C> where
    C: DivAssign<&'c C>, 

type Output = Polynomial<Var, C>

The resulting type after applying the / operator.

fn div(self, other: &'a C) -> Self::Output

Performs the / operation.

impl<Var, C: Coeff> Div<C> for Polynomial<Var, C> where
    C: DivAssign<&'c C>, 

type Output = Polynomial<Var, C>

The resulting type after applying the / operator.

fn div(self, other: C) -> Self::Output

Performs the / operation.

impl<'a, Var, C: Coeff, T> Div<T> for &'a Polynomial<Var, C> where
    PolynomialSlice<'a, Var, C>: Div<T, Output = Polynomial<Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the / operator.

fn div(self, other: T) -> Self::Output

Performs the / operation.

impl<'a, Var, C: Coeff> DivAssign<&'a C> for Polynomial<Var, C> where
    C: DivAssign<&'a C>, 

fn div_assign(&mut self, other: &'a C)

Divide each monomial by a factor

Example

use series::Polynomial;
let mut p = Polynomial::new("x", -3, vec!(1.,0.,-3.));
p /= &2.;
let res = Polynomial::new("x", -3, vec!(0.5,0.,-1.5));
assert_eq!(res, p);

impl<Var, C: Coeff> DivAssign<C> for Polynomial<Var, C> where
    C: DivAssign<&'a C>, 

fn div_assign(&mut self, other: C)

Divide each monomial by a factor

Example

use series::Polynomial;
let mut p = Polynomial::new("x", -3, vec!(1.,0.,-3.));
p /= 2.;
let res = Polynomial::new("x", -3, vec!(0.5,0.,-1.5));
assert_eq!(res, p);

impl<Var: Eq, C: Eq + Coeff> Eq for Polynomial<Var, C>

impl<Var, C: Coeff> From<Polynomial<Var, C>> for PolynomialParts<Var, C>

fn from(p: Polynomial<Var, C>) -> Self

Performs the conversion.

impl<'a, Var: Clone, C: Coeff + Clone> From<PolynomialSlice<'a, Var, C>> for Polynomial<Var, C>

fn from(s: PolynomialSlice<'a, Var, C>) -> Polynomial<Var, C>

Performs the conversion.

impl<Var, C: Coeff> From<Series<Var, C>> for Polynomial<Var, C>

fn from(s: Series<Var, C>) -> Self

Performs the conversion.

impl<Var: Hash, C: Hash + Coeff> Hash for Polynomial<Var, C>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<Var, C: Coeff> Index<isize> for Polynomial<Var, C>

type Output = C

The returned type after indexing.

fn index(&self, index: isize) -> &Self::Output

Get the coefficient of the polynomial variable to the given power.

Panics

Panics if the index is smaller than the leading power or bigger than the highest power

Example

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert_eq!(p[-1], 1);
assert_eq!(p[0], 2);
assert_eq!(p[1], 3);
assert!(std::panic::catch_unwind(|| p[-2]).is_err());
assert!(std::panic::catch_unwind(|| p[2]).is_err());

impl<Var, C: Coeff> IntoIterator for Polynomial<Var, C>

type Item = (isize, C)

The type of the elements being iterated over.

type IntoIter = IntoIter<C>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<C>

Consuming iterator over the polynomial powers and coefficients.

Example

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
let mut iter = p.into_iter();
assert_eq!(iter.next(), Some((-1, 1)));
assert_eq!(iter.next(), Some((0, 2)));
assert_eq!(iter.next(), Some((1, 3)));
assert_eq!(iter.next(), None);

impl<'a, 'b, Var: Clone, C: Coeff> KaratsubaMul<&'b Polynomial<Var, C>> for PolynomialSlice<'a, Var, C> where
    Var: Clone + PartialEq + Debug,
    C: Clone,
    C: AddAssign,
    Polynomial<Var, C>: AddAssign<&'c Polynomial<Var, C>> + SubAssign<&'c Polynomial<Var, C>>,
    Polynomial<Var, C>: AddAssign<Polynomial<Var, C>> + SubAssign<Polynomial<Var, C>>,
    PolynomialSlice<'c, Var, C>: Add<Output = Polynomial<Var, C>>,
    &'c C: Mul<Output = C>, 

type Output = Polynomial<Var, C>

fn karatsuba_mul(
    self,
    rhs: &'b Polynomial<Var, C>,
    min_size: usize
) -> Self::Output

Calculate self * rhs using Karatsuba multiplication.

impl<'a, 'b, Var: Clone, C: Coeff> KaratsubaMul<&'b Polynomial<Var, C>> for &'a Polynomial<Var, C> where
    Var: Clone + PartialEq + Debug,
    C: Clone,
    C: AddAssign,
    Polynomial<Var, C>: AddAssign<&'c Polynomial<Var, C>> + SubAssign<&'c Polynomial<Var, C>>,
    Polynomial<Var, C>: AddAssign<Polynomial<Var, C>> + SubAssign<Polynomial<Var, C>>,
    PolynomialSlice<'c, Var, C>: Add<Output = Polynomial<Var, C>>,
    &'c C: Mul<Output = C>, 

type Output = Polynomial<Var, C>

fn karatsuba_mul(
    self,
    rhs: &'b Polynomial<Var, C>,
    min_size: usize
) -> Self::Output

Calculate self * rhs using Karatsuba multiplication.

impl<'a, 'b, Var: Clone, C: Coeff> KaratsubaMul<PolynomialSlice<'b, Var, C>> for &'a Polynomial<Var, C> where
    Var: Clone + PartialEq + Debug,
    C: Clone,
    C: AddAssign,
    Polynomial<Var, C>: AddAssign<&'c Polynomial<Var, C>> + SubAssign<&'c Polynomial<Var, C>>,
    Polynomial<Var, C>: AddAssign<Polynomial<Var, C>> + SubAssign<Polynomial<Var, C>>,
    PolynomialSlice<'c, Var, C>: Add<Output = Polynomial<Var, C>>,
    &'c C: Mul<Output = C>, 

type Output = Polynomial<Var, C>

fn karatsuba_mul(
    self,
    rhs: PolynomialSlice<'b, Var, C>,
    min_size: usize
) -> Self::Output

Calculate self * rhs using Karatsuba multiplication.

impl<'a, Var, C: Coeff> Mul<&'a C> for Polynomial<Var, C> where
    C: MulAssign<&'c C>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, other: &'a C) -> Self::Output

Performs the * operation.

impl<'a, Var, C: Coeff> Mul<&'a Polynomial<Var, C>> for Polynomial<Var, C> where
    Polynomial<Var, C>: MulAssign<PolynomialSlice<'a, Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, other: &'a Polynomial<Var, C>) -> Self::Output

Performs the * operation.

impl<'a, 'b, Var, C: Coeff> Mul<&'b Polynomial<Var, C>> for PolynomialSlice<'a, Var, C> where
    PolynomialSlice<'a, Var, C>: Mul<PolynomialSlice<'b, Var, C>, Output = Polynomial<Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, other: &'b Polynomial<Var, C>) -> Self::Output

Performs the * operation.

impl<Var, C: Coeff> Mul<C> for Polynomial<Var, C> where
    C: MulAssign<&'c C>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, Var, C: Coeff> Mul<Polynomial<Var, C>> for PolynomialSlice<'a, Var, C> where
    PolynomialSlice<'a, Var, C>: Mul<PolynomialSlice<'b, Var, C>, Output = Polynomial<Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, other: Polynomial<Var, C>) -> Self::Output

Performs the * operation.

impl<Var, C: Coeff> Mul<Polynomial<Var, C>> for Polynomial<Var, C> where
    Polynomial<Var, C>: MulAssign, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, other: Polynomial<Var, C>) -> Self::Output

Performs the * operation.

impl<'a, Var, C: Coeff> Mul<PolynomialSlice<'a, Var, C>> for Polynomial<Var, C> where
    Polynomial<Var, C>: MulAssign<PolynomialSlice<'a, Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, other: PolynomialSlice<'a, Var, C>) -> Self::Output

Performs the * operation.

impl<'a, Var, C: Coeff, T> Mul<T> for &'a Polynomial<Var, C> where
    PolynomialSlice<'a, Var, C>: Mul<T, Output = Polynomial<Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, Var, C: Coeff> MulAssign<&'a C> for Polynomial<Var, C> where
    C: MulAssign<&'a C>, 

fn mul_assign(&mut self, other: &'a C)

Multiply each monomial by a factor

Example

use series::Polynomial;
let mut p = Polynomial::new("x", -3, vec!(1.,0.,-3.));
p *= &2.;
let res = Polynomial::new("x", -3, vec!(2.,0.,-6.));
assert_eq!(res, p);

impl<'a, Var: PartialEq + Debug, C: Coeff + Clone + AddAssign> MulAssign<&'a Polynomial<Var, C>> for Polynomial<Var, C> where
    Polynomial<Var, C>: MulAssign<PolynomialSlice<'a, Var, C>>, 

fn mul_assign(&mut self, other: &'a Polynomial<Var, C>)

Set p = p * q for two polynomials p,q

Example

use series::Polynomial;
let mut p = Polynomial::new("x", -3, vec!(1.,0.,-3.));
p *= &p.clone();
let res = Polynomial::new("x", -6, vec!(1.,0.,-6.,0.,9.));
assert_eq!(res, p);

Panics

Panics if the polynomials have different expansion variables.

impl<Var, C: Coeff> MulAssign<C> for Polynomial<Var, C> where
    C: MulAssign<&'a C>, 

fn mul_assign(&mut self, other: C)

Multiply each monomial by a factor

Example

use series::Polynomial;
let mut p = Polynomial::new("x", -3, vec!(1.,0.,-3.));
p *= 2.;
let res = Polynomial::new("x", -3, vec!(2.,0.,-6.));
assert_eq!(res, p);

impl<Var, C: Coeff> MulAssign<Polynomial<Var, C>> for Polynomial<Var, C> where
    Polynomial<Var, C>: MulAssign<&'a Polynomial<Var, C>>, 

fn mul_assign(&mut self, other: Polynomial<Var, C>)

Set p = p * q for two polynomials p,q

Example

use series::Polynomial;
let mut p = Polynomial::new("x", -3, vec!(1.,0.,-3.));
p *= &p.clone();
let res = Polynomial::new("x", -6, vec!(1.,0.,-6.,0.,9.));
assert_eq!(res, p);

Panics

Panics if the series have different expansion variables.

impl<'a, Var, C: Coeff> MulAssign<PolynomialSlice<'a, Var, C>> for Polynomial<Var, C> where
    PolynomialSlice<'b, Var, C>: Mul<PolynomialSlice<'a, Var, C>, Output = Polynomial<Var, C>>, 

fn mul_assign(&mut self, other: PolynomialSlice<'a, Var, C>)

Performs the *= operation.

impl<Var, C: Coeff + Neg<Output = C>> Neg for Polynomial<Var, C>

type Output = Polynomial<Var, C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Compute -p for a Laurent polynomial p

Example

let p = series::Polynomial::new("x", -3, vec!(1.,0.,-3.));
let minus_p = series::Polynomial::new("x", -3, vec!(-1.,0.,3.));
assert_eq!(-p, minus_p);

impl<'a, Var: Clone, C: Coeff> Neg for &'a Polynomial<Var, C> where
    PolynomialSlice<'a, Var, C>: Neg, 

type Output = <PolynomialSlice<'a, Var, C> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Compute -p for a Laurent polynomial p

Example

let p = series::Polynomial::new("x", -3, vec!(1.,0.,-3.));
let minus_p = series::Polynomial::new("x", -3, vec!(-1.,0.,3.));
assert_eq!(-&p, minus_p);

impl<Var: Ord, C: Ord + Coeff> Ord for Polynomial<Var, C>

fn cmp(&self, other: &Polynomial<Var, C>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use] fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use] fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use] fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<Var: PartialEq, C: PartialEq + Coeff> PartialEq<Polynomial<Var, C>> for Polynomial<Var, C>

fn eq(&self, other: &Polynomial<Var, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Polynomial<Var, C>) -> bool

This method tests for !=.

impl<Var: PartialOrd, C: PartialOrd + Coeff> PartialOrd<Polynomial<Var, C>> for Polynomial<Var, C>

fn partial_cmp(&self, other: &Polynomial<Var, C>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Polynomial<Var, C>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Polynomial<Var, C>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Polynomial<Var, C>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Polynomial<Var, C>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Var, C: Coeff> StructuralEq for Polynomial<Var, C>

impl<Var, C: Coeff> StructuralPartialEq for Polynomial<Var, C>

impl<Var, C: Coeff, T> Sub<T> for Polynomial<Var, C> where
    Polynomial<Var, C>: SubAssign<T>, 

type Output = Polynomial<Var, C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, Var, C: Coeff, T> Sub<T> for &'a Polynomial<Var, C> where
    PolynomialSlice<'a, Var, C>: Sub<T, Output = Polynomial<Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, Var, C: Coeff> SubAssign<&'a Polynomial<Var, C>> for Polynomial<Var, C> where
    &'c Polynomial<Var, C>: Neg<Output = Polynomial<Var, C>>,
    Polynomial<Var, C>: AddAssign<Polynomial<Var, C>>, 

fn sub_assign(&mut self, other: &'a Polynomial<Var, C>)

Set p = p - q for two polynomial p and q

Example

use series::Polynomial;
let mut p = Polynomial::new("x", -3, vec!(1.,0.,-3.));
let res = Polynomial::new("x", 0, vec!());
p -= &p.clone();
assert_eq!(res, p);

Panics

Panics if the polynomials have different expansion variables.

impl<'c, Var, C: Coeff> SubAssign<&'c C> for Polynomial<Var, C> where
    Polynomial<Var, C>: AddAssign<C>,
    C: AddAssign,
    &'c C: Neg<Output = C>, 

fn sub_assign(&mut self, other: &'c C)

Performs the -= operation.

impl<Var, C: Coeff> SubAssign<C> for Polynomial<Var, C> where
    Polynomial<Var, C>: AddAssign<C>,
    C: Neg<Output = C> + AddAssign, 

fn sub_assign(&mut self, other: C)

Performs the -= operation.

impl<Var, C: Coeff> SubAssign<Polynomial<Var, C>> for Polynomial<Var, C> where
    Polynomial<Var, C>: AddAssign + Neg<Output = Polynomial<Var, C>>, 

fn sub_assign(&mut self, other: Polynomial<Var, C>)

Set p = p - q for two polynomial p and q

Example

use series::Polynomial;
let mut p = Polynomial::new("x", -3, vec!(1.,0.,-3.));
let res = Polynomial::new("x", 0, vec!());
p -= p.clone();
assert_eq!(res, p);

Panics

Panics if the polynomial have different expansion variables.

impl<'a, Var, C: Coeff> SubAssign<PolynomialSlice<'a, Var, C>> for Polynomial<Var, C> where
    PolynomialSlice<'c, Var, C>: Neg<Output = Polynomial<Var, C>>,
    Polynomial<Var, C>: AddAssign<Polynomial<Var, C>>, 

fn sub_assign(&mut self, other: PolynomialSlice<'a, Var, C>)

Performs the -= operation.