Struct polynomials::Polynomial

pub struct Polynomial<T>(_);

A Polynomial is just a vector of coefficients. Each coefficient corresponds to a power of x in increasing order. For example, the following polynomial is equal to 4x^2 + 3x - 9.

// Construct polynomial 4x^2 + 3x - 9
let mut a = poly![-9, 3, 4];
assert_eq!(a[0], -9);
assert_eq!(a[1], 3);
assert_eq!(a[2], 4);

Implementations

impl<T> Polynomial<T>

pub fn new() -> Polynomial<T>

Create a new, empty, instance of a polynomial.

pub fn push(&mut self, value: T)

Adds a new coefficient to the Polynomial, in the next highest order position.

let mut a = poly![-8, 2, 4];
a.push(7);
assert_eq!(a, poly![-8, 2, 4, 7]);

pub fn pop(&mut self) -> Option<T>

Removes the highest order coefficient from the Polynomial.

let mut a = poly![-8, 2, 4];
assert_eq!(a.pop().unwrap(), 4);
assert_eq!(a, poly![-8, 2]);

pub fn degree(&self) -> usize where
    T: Sub<T, Output = T> + Eq + Copy, 

Calculates the degree of a Polynomial.

The following polynomial is of degree 2: (4x^2 + 2x - 8)

let a = poly![-8, 2, 4];
assert_eq!(a.degree(), 2);

pub fn eval<X>(&self, x: X) -> Option<T> where
    T: AddAssign + Copy,
    X: MulAssign + Mul<T, Output = T> + Copy, 

Evaluate a Polynomial for some value x.

The following example evaluates the polynomial (4x^2 + 2x - 8) for x = 3.

let a = poly![-8, 2, 4];
assert_eq!(a.eval(3).unwrap(), 34);

pub fn iter(&self) -> impl Iterator<Item = &T>

pub fn into_iter(self) -> impl IntoIterator<Item = T, IntoIter = IntoIter<T>>

Trait Implementations

impl<T: Add<Output = T>> Add<Polynomial<T>> for Polynomial<T> where
    T: Add + Copy + Clone, 

Add two Polynomials.

The following example adds two polynomials: (4x^2 + 2x - 8) + (x + 1) = (4x^2 + 3x - 7)

let a = poly![-8, 2, 4];
let b = poly![1, 1];
assert_eq!(a + b, poly![-7, 3, 4]);

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AddAssign<Polynomial<T>> for Polynomial<T> where
    T: Add<Output = T> + Copy, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone> Clone for Polynomial<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Polynomial<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Polynomial<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Div<T> for Polynomial<T> where
    T: DivAssign + Copy, 

Divide a Polynomial by some value.

The following example divides a polynomial (4x^2 + 2x - 8) by 2:

let p = poly![-8, 2, 4] / 2;
assert_eq!(p, poly![-4, 1, 2]);

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> DivAssign<T> for Polynomial<T> where
    T: DivAssign + Copy, 

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T> Eq for Polynomial<T> where
    T: Sub<T, Output = T> + Eq + Copy, 

impl<T> From<Vec<T>> for Polynomial<T>

fn from(v: Vec<T>) -> Self

Performs the conversion.

impl<T, I: SliceIndex<[T]>> Index<I> for Polynomial<T>

type Output = I::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, I: SliceIndex<[T]>> IndexMut<I> for Polynomial<T>

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T> Into<Vec<T>> for Polynomial<T>

fn into(self) -> Vec<T>

Performs the conversion.

impl<T> Mul<Polynomial<T>> for Polynomial<T> where
    T: Mul<Output = T> + AddAssign + Sub<Output = T>,
    T: Copy + Clone, 

Multiply a Polynomial by some value.

The following example multiplies a polynomial (4x^2 + 2x - 8) by 2:

let p = poly![-8, 2, 4] * 2;
assert_eq!(p, poly![-16, 4, 8]);

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T> Mul<T> for Polynomial<T> where
    T: MulAssign + Copy, 

Multiply two Polynomials.

The following example multiplies two polynomials: (4x^2 + 2x - 8) * (x + 1) = (4x^3 + 6x^2 - 6x - 8)

let a = poly![-8, 2, 4];
let b = poly![1, 1];
assert_eq!(a * b, poly![-8, -6, 6, 4]);

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> MulAssign<Polynomial<T>> for Polynomial<T> where
    T: Mul<Output = T> + AddAssign + Sub<Output = T>,
    T: Copy + Clone, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T> MulAssign<T> for Polynomial<T> where
    T: MulAssign + Copy, 

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T> PartialEq<Polynomial<T>> for Polynomial<T> where
    T: Sub<T, Output = T> + Eq + Copy, 

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

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

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

This method tests for !=.

impl<T> Serialize for Polynomial<T> where
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T: Sub<Output = T>> Sub<Polynomial<T>> for Polynomial<T> where
    T: Sub + Neg<Output = T> + Copy + Clone, 

Subtract two Polynomials.

The following example subtracts two polynomials: (4x^2 + 2x - 8) - (x + 1) = (4x^2 + x - 9)

let a = poly![-8, 2, 4];
let b = poly![1, 1];
assert_eq!(a - b, poly![-9, 1, 4]);

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.