Struct mathru::algebra::abstr::Polynomial

pub struct Polynomial<T> { /* fields omitted */ }

Polynomial expression

Implementations

impl<T> Polynomial<T>

pub fn from_coef(coef: Vec<T>) -> Polynomial<T>

Creates a new polynomial with the given coefficients

Arguments

• `coef: Coefficients

Panics

If the coef is an empty vector

Example

(1 + 2x + 3x^2)

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);

pub fn from_root(root: Vec<T>) -> Polynomial<T> where
    T: Field + Scalar, 

Creates a new polynomial from the given roots

https://en.wikipedia.org/wiki/Vieta%27s_formulas

Arguments

• root: Roots

Panics

If the root is an empty vector

Example

(x - 1)(x - 2)(x - 3) = -6 + 11x -6x^2 + x^3

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_root(vec![1.0, 2.0, 3.0]);

let b: Polynomial<f64> = Polynomial::from_coef(vec![-6.0, 11.0, -6.0, 1.0]);

assert_eq!(b, a);

impl<T> Polynomial<T> where
    T: Field + Scalar, 

pub fn eval(&self, x: T) -> T

Evaluate the polynomial with horner's rule

Argument

• x: The polynomial is evaluated at this value

Example

(1 + 2x + 3x^2) = p(x) \\\\
p(2) = 17

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);

assert_eq!(17.0, a.eval(2.0));

impl<T> Polynomial<T>

pub fn degree(&self) -> usize

Returns the degree of the polynomial

Example

deg(1 + 2x + 3x^2) =2

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);

assert_eq!(2, a.degree())

impl<T> Polynomial<T> where
    T: Zero + AbsDiffEq, 

pub fn reduce(self) -> Self

impl<T> Polynomial<T> where
    T: Field + Scalar, 

pub fn differentiate(&self) -> Polynomial<T>

Differentiate polynomial

Example

p(x) = 3x^2 + 5x^2 + 3x + 1

\frac{\partial p(x)}{\partial x} = 9x^2 + 10x + 3

use mathru::algebra::abstr::Polynomial;

let c: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 3.0, 5.0, 3.0]);
let c_s: Polynomial<f64> = Polynomial::from_coef(vec![3.0, 10.0, 9.0]);

assert_eq!(c_s, c.differentiate());

pub fn integrate(&self) -> Polynomial<T>

Integrate polynomial

Example

p(x) = 1 + 2x + 3x^2

\int p(x) dx = c + x + x^2 + x^3

use mathru::algebra::abstr::Polynomial;

let c: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);
let c_s: Polynomial<f64> = Polynomial::from_coef(vec![0.0, 1.0, 1.0, 1.0]);

assert_eq!(c_s, c.integrate());

Trait Implementations

impl<T> AbsDiffEq<Polynomial<T>> for Polynomial<T> where
    T: AbsDiffEq<Epsilon = T>, 

type Epsilon = T

Used for specifying relative comparisons.

pub fn default_epsilon() -> T

The default tolerance to use when testing values that are close together.

pub fn abs_diff_eq(&self, _other: &Polynomial<T>, _epsilon: T) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

pub fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<'a, 'b, T> Add<&'b Polynomial<T>> for &'a Polynomial<T> where
    T: MagmaAdd + Scalar, 

type Output = Polynomial<T>

The resulting type after applying the + operator.

pub fn add(self, rhs: &'b Polynomial<T>) -> Self::Output

Adds two polynomials

Example

(1 + 2x + 3x^2) + (1 + 2x) = 2 + 4x + 3x^2

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);
let b: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0]);
let c: Polynomial<f64> = Polynomial::from_coef(vec![2.0, 4.0, 3.0]);

assert_eq!(c, &a + &b);

impl<T> Add<Polynomial<T>> for Polynomial<T> where
    T: MagmaAdd + Scalar, 

type Output = Polynomial<T>

The resulting type after applying the + operator.

pub fn add(self, rhs: Polynomial<T>) -> Self::Output

Adds two polynomials

Example

(1 + 2x + 3x^2) + (1 + 2x) = 2 + 4x + 3x^2

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);
let b: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0]);
let c: Polynomial<f64> = Polynomial::from_coef(vec![2.0, 4.0, 3.0]);

assert_eq!(c, a + b);

impl<T> AddAssign<Polynomial<T>> for Polynomial<T> where
    T: MagmaAdd + Scalar, 

pub fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T> Display for Polynomial<T> where
    T: Display + Real, 

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

Formats the value using the given formatter.

impl<'a, 'b, T> Div<&'b Polynomial<T>> for &'a Polynomial<T> where
    T: Field + Scalar, 

type Output = (Polynomial<T>, Polynomial<T>)

The resulting type after applying the / operator.

pub fn div(self, rhs: &'b Polynomial<T>) -> Self::Output

Dividedes two polynomials

Example

(3x^3 + 5x^2 + 3x + 1) / (3x^2 + 2x + 1) = (x + 1)

use mathru::algebra::abstr::Polynomial;
use crate::mathru::algebra::abstr::Zero;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);
let b: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 1.0]);
let c: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 3.0, 5.0, 3.0]);

assert_eq!(b, (&c / &a).0);
assert_eq!(Polynomial::zero(), (&c / &a).1)

impl<T: Eq> Eq for Polynomial<T>

impl<T> Group<Addition> for Polynomial<T> where
    T: Group<Addition> + Loop<Addition> + Quasigroup<Addition> + Scalar + MagmaAdd + AbsDiffEq<Epsilon = T>, 

impl<T> GroupAdd for Polynomial<T> where
    T: GroupAdd + Group<Addition> + Loop<Addition> + Quasigroup<Addition> + Scalar + MagmaAdd + AbsDiffEq<Epsilon = T> + MonoidAdd, 

impl<T> Identity<Addition> for Polynomial<T> where
    T: Identity<Addition>, 

pub fn id() -> Self

The identity element.

impl<T> Loop<Addition> for Polynomial<T> where
    T: Loop<Addition> + Quasigroup<Addition> + Scalar + MagmaAdd + AbsDiffEq<Epsilon = T>, 

impl<T> Magma<Addition> for Polynomial<T> where
    T: MagmaAdd + Magma<Addition> + Scalar + AbsDiffEq<Epsilon = T>, 

pub fn operate(self, rhs: Self) -> Self

binary operation

impl<T> Magma<Multiplication> for Polynomial<T> where
    T: MagmaMul + MonoidAdd + Magma<Multiplication> + Scalar + AbsDiffEq<Epsilon = T>, 

pub fn operate(self, rhs: Self) -> Self

binary operation

impl<T> MagmaAdd for Polynomial<T> where
    T: MagmaAdd + Scalar + AbsDiffEq<Epsilon = T>, 

impl<T> MagmaMul for Polynomial<T> where
    T: MagmaMul + MonoidAdd + Scalar + AbsDiffEq<Epsilon = T>, 

impl<T> Monoid<Addition> for Polynomial<T> where
    T: MagmaAdd + Scalar + Identity<Addition> + AbsDiffEq<Epsilon = T>, 

impl<T> MonoidAdd for Polynomial<T> where
    T: Monoid<Addition> + SemigroupAdd + Zero + Scalar + AbsDiffEq<Epsilon = T>, 

impl<'a, 'b, T> Mul<&'b Polynomial<T>> for &'a Polynomial<T> where
    T: MagmaMul + MonoidAdd + Scalar, 

type Output = Polynomial<T>

The resulting type after applying the * operator.

pub fn mul(self, rhs: &'b Polynomial<T>) -> Self::Output

Multiplies two polynomials

Arguments

• `self': Factor
• `rhs?: Factor

Example

(1 + 2x + 3x^2)(1 + x) = (1 + 3x + 5x^2 + 3x^3)

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);
let b: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 1.0]);
let c: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 3.0, 5.0, 3.0]);

assert_eq!(c, &a * &b)

impl<T> Mul<Polynomial<T>> for Polynomial<T> where
    T: MagmaMul + MonoidAdd + Scalar, 

type Output = Polynomial<T>

The resulting type after applying the * operator.

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

Multiplies two polynomials

Arguments

• `self': Factor
• `rhs?: Factor

Example

(1 + 2x + 3x^2)(1 + x) = (1 + 3x + 5x^2 + 3x^3)

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);
let b: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 1.0]);
let c: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 3.0, 5.0, 3.0]);

assert_eq!(c, a * b)

impl<T> MulAssign<Polynomial<T>> for Polynomial<T> where
    T: MagmaMul + MonoidAdd + Scalar, 

pub fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<'a, T> Neg for &'a Polynomial<T> where
    T: Neg<Output = T> + Clone, 

type Output = Polynomial<T>

The resulting type after applying the - operator.

pub fn neg(self) -> Self::Output

Negates the polynomial

Example

-(1 + 2x) = -1 - 2x

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0]);

assert_eq!(Polynomial::from_coef(vec![-1.0, -2.0]), -a);

impl<T> Neg for Polynomial<T> where
    T: Neg<Output = T>, 

type Output = Polynomial<T>

The resulting type after applying the - operator.

pub fn neg(self) -> Self::Output

Returns the negative of a polynomial

Example

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);

assert_eq!(Polynomial::from_coef(vec![-1.0, -2.0, -3.0]), -a)

impl<T: PartialEq> PartialEq<Polynomial<T>> for Polynomial<T>

pub fn eq(&self, other: &Polynomial<T>) -> bool

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

pub fn ne(&self, other: &Polynomial<T>) -> bool

This method tests for !=.

impl<T> Quasigroup<Addition> for Polynomial<T> where
    T: Quasigroup<Addition> + Scalar + MagmaAdd + AbsDiffEq<Epsilon = T>, 

impl<T> Semigroup<Addition> for Polynomial<T> where
    T: MagmaAdd + Scalar + AbsDiffEq<Epsilon = T>, 

pub fn is_associative(self, y: Self, z: Self) -> bool

impl<T> SemigroupAdd for Polynomial<T> where
    T: SemigroupAdd + Semigroup<Addition> + MagmaAdd + Scalar + AbsDiffEq<Epsilon = T>, 

impl<T> StructuralEq for Polynomial<T>

impl<T> StructuralPartialEq for Polynomial<T>

impl<'a, 'b, T> Sub<&'b Polynomial<T>> for &'a Polynomial<T> where
    T: Sub<Output = T> + Scalar, 

type Output = Polynomial<T>

The resulting type after applying the - operator.

pub fn sub(self, rhs: &'b Polynomial<T>) -> Self::Output

Subtracts two polynomials

Example

(1 + 2x + 3x^2) - (1 + 2x) = 3x^2

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);
let b: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0]);
let c: Polynomial<f64> = Polynomial::from_coef(vec![0.0, 0.0, 3.0]);

assert_eq!(c, &a - &b);

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

type Output = Polynomial<T>

The resulting type after applying the - operator.

pub fn sub(self, rhs: Polynomial<T>) -> Self::Output

Subtracts two polynomials

Example

(1 + 2x + 3x^2) + (1 + 2x) = 2 + 4x + 3x^2

use mathru::algebra::abstr::Polynomial;

let a: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0, 3.0]);
let b: Polynomial<f64> = Polynomial::from_coef(vec![1.0, 2.0]);
let c: Polynomial<f64> = Polynomial::from_coef(vec![0.0, 0.0, 3.0]);

assert_eq!(c, a - b);

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

pub fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

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

pub fn zero() -> Polynomial<T>