Struct rust_poly::Poly

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

Implementations

impl<T: Scalar> Poly<T>

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

pub fn from_roots(roots: DVector<Complex<T>>) -> Self

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

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

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

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

use rust_poly::Poly;
use rust_poly::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), Complex::new(4.0, 0.0)]);
dbg!(p.roots());
assert!(false);

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::identities::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);

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: &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: Self) -> Self::Output

Performs the + operation.

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> 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: &Self) -> Self::Output

Performs the * 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: Self) -> Self::Output

Performs the * 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> 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>