Struct polynomial::Polynomial

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

A polynomial.

Implementations

impl<T: Zero> Polynomial<T>

pub fn new(data: Vec<T>) -> Self

Creates a new Polynomial from a Vec of coefficients.

Examples

use polynomial::Polynomial;
let poly = Polynomial::new(vec![1, 2, 3]);
assert_eq!("1+2*x+3*x^2", poly.pretty("x"));

impl<T> Polynomial<T>where T: One + Zero + Clone + Neg<Output = T> + Div<Output = T> + Mul<Output = T> + Sub<Output = T>,

pub fn lagrange(xs: &[T], ys: &[T]) -> Option<Self>

Creates the Lagrange polynomial that fits a number of points.

Returns None if any two x-coordinates are the same.

Examples

use polynomial::Polynomial;
let poly = Polynomial::lagrange(&[1, 2, 3], &[10, 40, 90]).unwrap();
println!("{}", poly.pretty("x"));
assert_eq!("10*x^2", poly.pretty("x"));

impl<T> Polynomial<T>where T: One + Zero + Clone + Neg<Output = T> + Div<Output = T> + Mul<Output = T> + Sub<Output = T> + FromPrimitive,

pub fn chebyshev<F: Fn(T) -> T>( f: &F, n: usize, xmin: f64, xmax: f64 ) -> Option<Self>

Chebyshev approximation fits a function to a polynomial over a range of values.

This attempts to minimize the maximum error.

Retrurns None if n < 1 or xmin >= xmax.

Examples

use polynomial::Polynomial;
use std::f64::consts::PI;
let p = Polynomial::chebyshev(&f64::sin, 7, -PI/4., PI/4.).unwrap();
assert!((p.eval(0.) - (0.0_f64).sin()).abs() < 0.0001);
assert!((p.eval(0.1) - (0.1_f64).sin()).abs() < 0.0001);
assert!((p.eval(-0.1) - (-0.1_f64).sin()).abs() < 0.0001);

impl<T: Zero + Mul<Output = T> + Clone> Polynomial<T>

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

Evaluates the polynomial at a point.

Examples

use polynomial::Polynomial;
let poly = Polynomial::new(vec![1, 2, 3]);
assert_eq!(1, poly.eval(0));
assert_eq!(6, poly.eval(1));
assert_eq!(17, poly.eval(2));

impl<T> Polynomial<T>

pub fn data(&self) -> &[T]

Gets the slice of internal data.

impl<T> Polynomial<T>where T: Zero + One + Eq + Neg<Output = T> + Ord + Display + Clone,

pub fn pretty(&self, x: &str) -> String

Pretty prints the polynomial.

Trait Implementations

impl<'a, 'b, Lhs, Rhs> Add<&'b Polynomial<Rhs>> for &'a Polynomial<Lhs>where Lhs: Zero + Add<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Add<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Add<Rhs>>::Output>

The resulting type after applying the + operator.

fn add(self, other: &Polynomial<Rhs>) -> Polynomial<<Lhs as Add<Rhs>>::Output>

Performs the + operation.

impl<'a, Lhs, Rhs> Add<&'a Polynomial<Rhs>> for Polynomial<Lhs>where Lhs: Zero + Add<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Add<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Add<Rhs>>::Output>

The resulting type after applying the + operator.

fn add(self, other: &Polynomial<Rhs>) -> Polynomial<<Lhs as Add<Rhs>>::Output>

Performs the + operation.

impl<'a, Lhs, Rhs> Add<Polynomial<Rhs>> for &'a Polynomial<Lhs>where Lhs: Zero + Add<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Add<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Add<Rhs>>::Output>

The resulting type after applying the + operator.

fn add(self, other: Polynomial<Rhs>) -> Polynomial<<Lhs as Add<Rhs>>::Output>

Performs the + operation.

impl<Lhs, Rhs> Add<Polynomial<Rhs>> for Polynomial<Lhs>where Lhs: Zero + Add<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Add<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Add<Rhs>>::Output>

The resulting type after applying the + operator.

fn add(self, other: Polynomial<Rhs>) -> Polynomial<<Lhs as Add<Rhs>>::Output>

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<'a, 'b, Lhs, Rhs> Mul<&'b Polynomial<Rhs>> for &'a Polynomial<Lhs>where Lhs: Zero + Mul<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Mul<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Mul<Rhs>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: &Polynomial<Rhs>) -> Polynomial<<Lhs as Mul<Rhs>>::Output>

Performs the * operation.

impl<'a, Lhs, Rhs> Mul<&'a Polynomial<Rhs>> for Polynomial<Lhs>where Lhs: Zero + Mul<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Mul<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Mul<Rhs>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: &Polynomial<Rhs>) -> Polynomial<<Lhs as Mul<Rhs>>::Output>

Performs the * operation.

impl<'a, Lhs, Rhs> Mul<Polynomial<Rhs>> for &'a Polynomial<Lhs>where Lhs: Zero + Mul<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Mul<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Mul<Rhs>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: Polynomial<Rhs>) -> Polynomial<<Lhs as Mul<Rhs>>::Output>

Performs the * operation.

impl<Lhs, Rhs> Mul<Polynomial<Rhs>> for Polynomial<Lhs>where Lhs: Zero + Mul<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Mul<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Mul<Rhs>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: Polynomial<Rhs>) -> Polynomial<<Lhs as Mul<Rhs>>::Output>

Performs the * operation.

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

type Output = Polynomial<<T as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Polynomial<<T as Neg>::Output>

Performs the unary - operation.

impl<T> Neg for Polynomial<T>where T: Neg + Zero + Clone, <T as Neg>::Output: Zero,

type Output = Polynomial<<T as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Polynomial<<T as Neg>::Output>

Performs the unary - operation.

impl<T: Zero + One + Clone> One for Polynomial<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.

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

fn eq(&self, other: &Polynomial<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<'a, 'b, Lhs, Rhs> Sub<&'b Polynomial<Rhs>> for &'a Polynomial<Lhs>where Lhs: Zero + Sub<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Sub<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Sub<Rhs>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: &Polynomial<Rhs>) -> Polynomial<<Lhs as Sub<Rhs>>::Output>

Performs the - operation.

impl<'a, Lhs, Rhs> Sub<&'a Polynomial<Rhs>> for Polynomial<Lhs>where Lhs: Zero + Sub<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Sub<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Sub<Rhs>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: &Polynomial<Rhs>) -> Polynomial<<Lhs as Sub<Rhs>>::Output>

Performs the - operation.

impl<'a, Lhs, Rhs> Sub<Polynomial<Rhs>> for &'a Polynomial<Lhs>where Lhs: Zero + Sub<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Sub<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Sub<Rhs>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: Polynomial<Rhs>) -> Polynomial<<Lhs as Sub<Rhs>>::Output>

Performs the - operation.

impl<Lhs, Rhs> Sub<Polynomial<Rhs>> for Polynomial<Lhs>where Lhs: Zero + Sub<Rhs> + Clone, Rhs: Zero + Clone, <Lhs as Sub<Rhs>>::Output: Zero,

type Output = Polynomial<<Lhs as Sub<Rhs>>::Output>

The resulting type after applying the - operator.

fn sub(self, other: Polynomial<Rhs>) -> Polynomial<<Lhs as Sub<Rhs>>::Output>

Performs the - operation.

impl<T: Zero + Clone> Zero for Polynomial<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> Eq for Polynomial<T>

impl<T> StructuralEq for Polynomial<T>

impl<T> StructuralPartialEq for Polynomial<T>