Struct rust_poly::Poly

pub struct Poly<T: Scalar>(_);

Implementations

impl<T: Scalar> Poly<T>

pub fn new(coeffs: &[Complex<T>]) -> Self

pub const fn from_dvector(value: DVector<Complex<T>>) -> Self

pub fn from_complex_slice(value: &[Complex<T>]) -> Self

The same as Poly::new()

pub fn from_complex_vec(value: Vec<Complex<T>>) -> Self

pub fn from_real_slice(value: &[T]) -> Self

pub fn from_real_vec(value: Vec<T>) -> Self

pub fn from_roots(roots: &[Complex<T>]) -> Self

Monic polynomial from its complex roots.

Examples

use rust_poly::Poly;
use num_complex::Complex;
use num_traits::{Zero, One};

let p = Poly::from_roots(&[Complex::new(-1.0, 0.0), Complex::zero(), Complex::one()]);
assert_eq!(p, Poly::new(&[Complex::zero(), Complex::new(-1.0, 0.0), Complex::zero(), Complex::one()]))

pub fn line(offset: Complex<T>, slope: Complex<T>) -> Self

Linear function as a polynomial.

Examples

use rust_poly::Poly;
use num_complex::Complex;
use num_traits::{One, Zero};

assert_eq!(Poly::line(Complex::one(), Complex::new(-1.0, 0.0)).eval_point(Complex::one()), Complex::zero());

pub fn line_from_points( p1: (Complex<T>, Complex<T>), p2: (Complex<T>, Complex<T>) ) -> Self

Line between two points with complex coordinates.

Note that the points are determined by two complex numbers, so they are in a four dimensional space. Leave the imaginary component as zero for lines in a 2D plane.

Examples

use rust_poly::Poly;
use num_complex::Complex;
use num_traits::{One, Zero};

let p1 = (Complex::new(-1.0, 0.0), Complex::new(2.0, 0.0));
let p2 = (Complex::new(2.0, 0.0), Complex::new(-1.0, 0.0));

assert_eq!(Poly::line_from_points(p1, p2).eval_point(Complex::one()), Complex::zero());

pub fn term(coeff: Complex<T>, degree: u32) -> Self

Create a polynomial from a single term (coefficient + degree)

Examples

use rust_poly::{poly, Poly};
use num_complex::Complex;
use num_traits::One;

assert_eq!(Poly::term(Complex::one(), 3), poly![0.0, 0.0, 0.0, 1.0]);

pub fn get_term(&self, degree: u32) -> Option<Self>

Get the nth term of the polynomial as a new polynomial

Will return None if out of bounds.

Examples

use rust_poly::{poly, Poly};
use num_complex::Complex;
use num_traits::One;

let p  = poly![1.0, 2.0, 3.0];
assert_eq!(p.get_term(1).unwrap(), poly![0.0, 2.0]);

pub fn cheby(n: usize) -> Self

Get the nth chebyshev polynomial

use rust_poly::{poly, Poly};

assert_eq!(Poly::cheby(2), poly![-1.0, 0.0, 2.0]);
assert_eq!(Poly::cheby(3), poly![0.0, -3.0, 0.0, 4.0]);
assert_eq!(Poly::cheby(4), poly![1.0, 0.0, -8.0, 0.0, 8.0])

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn eval_point(&self, x: Complex<T>) -> Complex<T>

Evaluate the polynomial at a single value of x.

use rust_poly::Poly;
use num_complex::Complex;

let p = Poly::new(&[Complex::new(1.0, 0.0), Complex::new(2.0, 0.0), Complex::new(3.0, 0.0)]);
let x = Complex::new(1.0, 0.0);
assert_eq!(p.eval_point(x), Complex::new(6.0, 0.0));

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

Evaluate the polynomial for each entry of a matrix.

pub fn pow(&self, pow: u32) -> Self

Raises a polynomial to an integer power.

use rust_poly::{poly, Poly};
use num_complex::Complex;

assert_eq!(poly![1.0, 2.0, 3.0].pow(2), poly![1.0, 4.0, 10.0, 12.0, 9.0]);

pub fn pow_usize(&self, pow: usize) -> Self

pub fn roots(&self) -> Vec<Complex<T>>

Find the roots of a polynomial numerically.

Examples

use rust_poly::{poly, Poly};
use rust_poly::num_complex::Complex;

let p: Poly<f64> = poly![-6.0, 11.0, -6.0, 1.0];
let expected_roots = &[Complex::new(1.0, 0.0), Complex::new(2.0, 0.0), Complex::new(3.0, 0.0)];
let temp = p.roots();    // Rust is really annoying sometimes...
let calculated_roots = temp.as_slice();

// assert almost equal
assert!((expected_roots[0] - calculated_roots[0]).re.abs() < 0.000001);
assert!((expected_roots[1] - calculated_roots[1]).re.abs() < 0.000001);
assert!((expected_roots[2] - calculated_roots[2]).re.abs() < 0.000001);

pub fn compose(&self, x: Self) -> Self

Compose two polynomials, returning a new polynomial.

Substitute the given polynomial x into self and expand the result into a new polynomial.

Examples

use rust_poly::Poly;
use num_complex::Complex;
use num_traits::One;

let f = Poly::new(&[Complex::new(1.0, 0.0), Complex::new(2.0, 0.0)]);
let g = Poly::one();

assert_eq!(f.compose(g), f);

pub fn div_rem(self, rhs: &Self) -> (Self, Self)

Calculate the quotient and remainder uwing long division. More efficient than calculating them separately.

Panics

Panics if a division by zero is attempted

Examples

use rust_poly::Poly;
use num_complex::Complex;
use num_traits::identities::One;

let c1 = Poly::new(&[Complex::new(1.0, 0.0), Complex::new(2.0, 0.0), Complex::new(3.0, 0.0)]);
let c2 = Poly::new(&[Complex::new(3.0, 0.0), Complex::new(2.0, 0.0), Complex::new(1.0, 0.0)]);
let expected1 = (Poly::new(&[Complex::new(3.0, 0.0)]), Poly::new(&[Complex::new(-8.0, 0.0), Complex::new(-4.0, 0.0)]));
assert_eq!(c1.clone().div_rem(&c2), expected1);

pub fn as_slice(&self) -> &[Complex<T>]

pub fn as_mut_slice(&mut self) -> &mut [Complex<T>]

pub fn as_ptr(&self) -> *const Complex<T>

pub fn as_mut_ptr(&mut self) -> *mut Complex<T>

pub fn as_view(&self) -> DMatrixView<'_, Complex<T>>

pub fn as_view_mut(&mut self) -> DMatrixViewMut<'_, Complex<T>>

pub fn to_vec(&self) -> Vec<Complex<T>>

pub fn to_dvector(&self) -> DVector<Complex<T>>

Trait Implementations

impl<T: Scalar> Add<&Poly<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Poly<T>) -> Self::Output

Performs the + operation.

impl<T: Scalar> Add<&Poly<T>> for Poly<T>

type Output = Poly<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<T: Scalar> Add<Poly<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Scalar> Add<Poly<T>> for Poly<T>

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

Add two polynomials

Examples

use rust_poly::{poly, Poly};

let p1 = poly![1.0, 2.0, 3.0];
let p2 = poly![4.0, 5.0];
assert_eq!(p1 + p2, poly![5.0, 7.0, 3.0]);

type Output = Poly<T>

The resulting type after applying the + operator.

impl<T: Clone + Scalar> Clone for Poly<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Scalar> Debug for Poly<T>

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

Formats the value using the given formatter.

impl<T: Scalar> Div<&Complex<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Scalar> Div<&Complex<T>> for Poly<T>

type Output = Poly<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Scalar> Div<&Poly<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Scalar> Div<&Poly<T>> for Poly<T>

type Output = Poly<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Scalar> Div<Complex<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Scalar> Div<Complex<T>> for Poly<T>

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

use rust_poly::{poly, Poly};
use num_complex::Complex;

let p = poly![2.0, 4.0, 6.0];
assert_eq!(p / Complex::from(2.0), poly![1.0, 2.0, 3.0]);

type Output = Poly<T>

The resulting type after applying the / operator.

impl<T: Scalar> Div<Poly<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Scalar> Div<Poly<T>> for Poly<T>

type Output = Poly<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Scalar> From<&[Complex<T>]> for Poly<T>

fn from(value: &[Complex<T>]) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<&[T]> for Poly<T>

fn from(value: &[T]) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<Matrix<Complex<T>, Dyn, Const<1>, VecStorage<Complex<T>, Dyn, Const<1>>>> for Poly<T>

fn from(value: DVector<Complex<T>>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<Poly<T>> for *const Complex<T>

fn from(val: Poly<T>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<Poly<T>> for *mut Complex<T>

fn from(val: Poly<T>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<Poly<T>> for DVector<Complex<T>>

fn from(val: Poly<T>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<Poly<T>> for Vec<Complex<T>>

fn from(val: Poly<T>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<Vec<Complex<T>, Global>> for Poly<T>

fn from(value: Vec<Complex<T>>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<Vec<T, Global>> for Poly<T>

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

Converts to this type from the input type.

impl<T: Scalar> Index<usize> for Poly<T>

type Output = Complex<T>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Scalar> Mul<&Complex<T>> for Poly<T>

type Output = Poly<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Scalar> Mul<&Poly<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Scalar> Mul<&Poly<T>> for Poly<T>

type Output = Poly<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Scalar> Mul<Complex<T>> for Poly<T>

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

use rust_poly::{poly, Poly};
use num_complex::Complex;

let p = poly![1.0, 2.0, 3.0];
assert_eq!(p * Complex::from(2.0), poly![2.0, 4.0, 6.0]);

type Output = Poly<T>

The resulting type after applying the * operator.

impl<T: Scalar> Mul<Poly<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Scalar> Mul<Poly<T>> for Poly<T>

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

Multiply two polynomials.

Examples

use rust_poly::{poly, Poly};
use num_complex::Complex;

let p1 = poly![1.0, 2.0, 3.0];
let p2 = poly![3.0, 2.0, 1.0];
assert_eq!(p1 * p2, poly![3.0, 8.0, 14.0, 8.0, 3.0]);

type Output = Poly<T>

The resulting type after applying the * operator.

impl<T: Scalar> Neg for &Poly<T>

type Output = Poly<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Scalar> Neg for Poly<T>

type Output = Poly<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Scalar> One for Poly<T>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> boolwhere Self: PartialEq<Self>,

Returns true if self is equal to the multiplicative identity.

impl<T: PartialEq + Scalar> PartialEq<Poly<T>> for Poly<T>

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Scalar> Rem<&Poly<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &Poly<T>) -> Self::Output

Performs the % operation.

impl<T: Scalar> Rem<&Poly<T>> for Poly<T>

type Output = Poly<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<T: Scalar> Rem<Poly<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Poly<T>) -> Self::Output

Performs the % operation.

impl<T: Scalar> Rem<Poly<T>> for Poly<T>

type Output = Poly<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: Scalar> Sub<&Poly<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Poly<T>) -> Self::Output

Performs the - operation.

impl<T: Scalar> Sub<&Poly<T>> for Poly<T>

type Output = Poly<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<T: Scalar> Sub<Poly<T>> for &Poly<T>

type Output = Poly<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Scalar> Sub<Poly<T>> for Poly<T>

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

Subtract two polynomials.

Examples

use rust_poly::{poly, Poly};
use num_complex::Complex;

let c1 = poly![1.0, 2.0, 3.0];
let c2 = poly![3.0, 2.0, 1.0];
assert_eq!(c1.clone() - c2.clone(), poly![-2.0, 0.0, 2.0]);
assert_eq!(c2 - c1, poly![2.0, 0.0, -2.0]);

type Output = Poly<T>

The resulting type after applying the - operator.

impl<T: Scalar> Sum<Poly<T>> for Poly<T>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T: Scalar> Zero for Poly<T>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T: Eq + Scalar> Eq for Poly<T>

impl<T: Scalar> StructuralEq for Poly<T>

impl<T: Scalar> StructuralPartialEq for Poly<T>