Struct LinearBinomial

pub struct LinearBinomial<N> {
    pub coefficients: [N; 2],
}

A type that stores terms of a linear binomial in a static array. Operations are much faster than on Polynomial for the same size polynomial, but terms can not be added freely.

Fields

coefficients: [N; 2]

Implementations

impl<N: Sized> LinearBinomial<N>

pub fn new(coefficients: [N; 2]) -> LinearBinomial<N>

Create a LinearBinomial with the given terms.

Example

use rustnomial::{SizedPolynomial, LinearBinomial, Degree};
let binomial = LinearBinomial::new([3, 2]);
assert_eq!(Degree::Num(1), binomial.degree());

impl<N: Zero + Copy> LinearBinomial<N>

pub fn ordered_term_iter(&self) -> impl Iterator<Item = (N, usize)> + '_

impl<N> LinearBinomial<N>

where N: Copy + Neg<Output = N> + Div<Output = N> + Zero,

pub fn root(&self) -> Roots<N>

Return the root of LinearBinomial.

Example

use rustnomial::{LinearBinomial, Roots, SizedPolynomial};
let binomial = LinearBinomial::new([1.0, 2.0]);
assert_eq!(Roots::OneRealRoot(-2.0), binomial.root());
let zero = LinearBinomial::<i32>::zero();
assert_eq!(Roots::InfiniteRoots, zero.root());
let constant = LinearBinomial::new([0, 1]);
assert_eq!(Roots::NoRoots, constant.root());

Trait Implementations

impl<N> Add for LinearBinomial<N>

where N: Add<Output = N> + Copy,

type Output = LinearBinomial<N>

The resulting type after applying the + operator.

fn add(self, rhs: LinearBinomial<N>) -> LinearBinomial<N>

Performs the + operation.

impl<N: Copy + AddAssign> AddAssign for LinearBinomial<N>

fn add_assign(&mut self, rhs: LinearBinomial<N>)

Performs the += operation.

impl<N: Clone> Clone for LinearBinomial<N>

fn clone(&self) -> LinearBinomial<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug> Debug for LinearBinomial<N>

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

Formats the value using the given formatter.

impl<N> Derivable<N> for LinearBinomial<N>

where N: Zero + One + Copy + Mul<Output = N> + TryFromUsizeExact,

fn derivative(&self) -> LinearBinomial<N>

Returns the derivative of the LinearBinomial.

Example

use rustnomial::{LinearBinomial, Derivable};
let binomial = LinearBinomial::new([3.0, 1.0]);
assert_eq!(LinearBinomial::new([0., 3.0]), binomial.derivative());

impl<N> Display for LinearBinomial<N>

where N: Zero + One + IsPositive + PartialEq + Abs + Copy + IsNegativeOne + Display,

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

Formats the value using the given formatter.

impl<N: Div<Output = N> + Copy> Div<N> for LinearBinomial<N>

type Output = LinearBinomial<N>

The resulting type after applying the / operator.

fn div(self, rhs: N) -> LinearBinomial<N>

Performs the / operation.

impl<N: DivAssign + Copy> DivAssign<N> for LinearBinomial<N>

fn div_assign(&mut self, rhs: N)

Performs the /= operation.

impl<N> Evaluable<N> for LinearBinomial<N>

where N: Add<Output = N> + Mul<Output = N> + Copy,

fn eval(&self, point: N) -> N

Returns the value of the LinearBinomial at the given point.

Example

use rustnomial::{LinearBinomial, Evaluable};
let binomial = LinearBinomial::new([1, 2]);
assert_eq!(7, binomial.eval(5));
assert_eq!(2, binomial.eval(0));

impl From<LinearBinomial<f32>> for LinearBinomial<f64>

fn from(item: LinearBinomial<f32>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i16>> for LinearBinomial<f32>

fn from(item: LinearBinomial<i16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i16>> for LinearBinomial<f64>

fn from(item: LinearBinomial<i16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i16>> for LinearBinomial<i128>

fn from(item: LinearBinomial<i16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i16>> for LinearBinomial<i32>

fn from(item: LinearBinomial<i16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i16>> for LinearBinomial<i64>

fn from(item: LinearBinomial<i16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i32>> for LinearBinomial<f64>

fn from(item: LinearBinomial<i32>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i32>> for LinearBinomial<i128>

fn from(item: LinearBinomial<i32>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i32>> for LinearBinomial<i64>

fn from(item: LinearBinomial<i32>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i64>> for LinearBinomial<i128>

fn from(item: LinearBinomial<i64>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i8>> for LinearBinomial<f32>

fn from(item: LinearBinomial<i8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i8>> for LinearBinomial<f64>

fn from(item: LinearBinomial<i8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i8>> for LinearBinomial<i128>

fn from(item: LinearBinomial<i8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i8>> for LinearBinomial<i16>

fn from(item: LinearBinomial<i8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i8>> for LinearBinomial<i32>

fn from(item: LinearBinomial<i8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<i8>> for LinearBinomial<i64>

fn from(item: LinearBinomial<i8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u16>> for LinearBinomial<f32>

fn from(item: LinearBinomial<u16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u16>> for LinearBinomial<f64>

fn from(item: LinearBinomial<u16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u16>> for LinearBinomial<i128>

fn from(item: LinearBinomial<u16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u16>> for LinearBinomial<i32>

fn from(item: LinearBinomial<u16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u16>> for LinearBinomial<i64>

fn from(item: LinearBinomial<u16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u16>> for LinearBinomial<u128>

fn from(item: LinearBinomial<u16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u16>> for LinearBinomial<u32>

fn from(item: LinearBinomial<u16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u16>> for LinearBinomial<u64>

fn from(item: LinearBinomial<u16>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u32>> for LinearBinomial<f64>

fn from(item: LinearBinomial<u32>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u32>> for LinearBinomial<i128>

fn from(item: LinearBinomial<u32>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u32>> for LinearBinomial<i64>

fn from(item: LinearBinomial<u32>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u32>> for LinearBinomial<u128>

fn from(item: LinearBinomial<u32>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u32>> for LinearBinomial<u64>

fn from(item: LinearBinomial<u32>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u64>> for LinearBinomial<i128>

fn from(item: LinearBinomial<u64>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u64>> for LinearBinomial<u128>

fn from(item: LinearBinomial<u64>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u8>> for LinearBinomial<f32>

fn from(item: LinearBinomial<u8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u8>> for LinearBinomial<f64>

fn from(item: LinearBinomial<u8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u8>> for LinearBinomial<i128>

fn from(item: LinearBinomial<u8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u8>> for LinearBinomial<i16>

fn from(item: LinearBinomial<u8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u8>> for LinearBinomial<i32>

fn from(item: LinearBinomial<u8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u8>> for LinearBinomial<i64>

fn from(item: LinearBinomial<u8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u8>> for LinearBinomial<u128>

fn from(item: LinearBinomial<u8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u8>> for LinearBinomial<u16>

fn from(item: LinearBinomial<u8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u8>> for LinearBinomial<u32>

fn from(item: LinearBinomial<u8>) -> Self

Converts to this type from the input type.

impl From<LinearBinomial<u8>> for LinearBinomial<u64>

fn from(item: LinearBinomial<u8>) -> Self

Converts to this type from the input type.

impl<N> FromStr for LinearBinomial<N>

where N: Zero + One + Copy + SubAssign + AddAssign + FromStr + CanNegate,

type Err = PolynomialFromStringError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<N> Integrable<N, Polynomial<N>> for LinearBinomial<N>

where N: Zero + Copy + DivAssign + Mul<Output = N> + MulAssign + AddAssign + Div<Output = N> + TryFromUsizeContinuous,

fn integral(&self) -> Integral<N, Polynomial<N>>

Returns the integral of the LinearBinomial.

Example

use rustnomial::{LinearBinomial, Integrable, Polynomial};
let binomial = LinearBinomial::new([2.0, 0.]);
let integral = binomial.integral();
assert_eq!(&Polynomial::new(vec![1.0, 0.0, 0.0]), integral.inner());

Will panic if N can not losslessly represent 2usize.

impl<N: Mul<Output = N> + Copy> Mul<N> for LinearBinomial<N>

type Output = LinearBinomial<N>

The resulting type after applying the * operator.

fn mul(self, rhs: N) -> LinearBinomial<N>

Performs the * operation.

impl<N: MulAssign + Copy> MulAssign<N> for LinearBinomial<N>

fn mul_assign(&mut self, rhs: N)

Performs the *= operation.

impl<N> MutablePolynomial<N> for LinearBinomial<N>

where N: Zero + SubAssign + AddAssign + Copy,

fn try_add_term(&mut self, coeff: N, degree: usize) -> Result<(), TryAddError>

Tries to add the term with given coefficient and degree to self, returning an error if the particular term can not be added to self without violating constraints.

fn try_sub_term(&mut self, coeff: N, degree: usize) -> Result<(), TryAddError>

Tries to subtract the term with given coefficient and degree from self, returning an error if the particular term can not be subtracted from self without violating constraints.

impl<N: Copy + Neg<Output = N>> Neg for LinearBinomial<N>

type Output = LinearBinomial<N>

The resulting type after applying the - operator.

fn neg(self) -> LinearBinomial<N>

Performs the unary - operation.

impl<N> PartialEq for LinearBinomial<N>

where N: Zero + PartialEq + Copy,

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

Returns true if this LinearBinomial and other are equal.

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

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

impl<N: Zero + Copy> Shr<u32> for LinearBinomial<N>

type Output = LinearBinomial<N>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> LinearBinomial<N>

Performs the >> operation.

impl<N: Zero + Copy> ShrAssign<u32> for LinearBinomial<N>

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<N: Copy + Zero> SizedPolynomial<N> for LinearBinomial<N>

fn term_with_degree(&self, degree: usize) -> Term<N>

Returns the term with the given degree of the LinearBinomial.

Example

use rustnomial::{LinearBinomial, SizedPolynomial, Term};
let binomial = LinearBinomial::new([5, 0]);
assert_eq!(Term::Term(5, 1), binomial.term_with_degree(1));
assert_eq!(Term::ZeroTerm, binomial.term_with_degree(0));

fn degree(&self) -> Degree

Returns the degree of the LinearBinomial.

Example

use rustnomial::{SizedPolynomial, LinearBinomial, Degree};
let binomial = LinearBinomial::new([3.0, 2.0]);
assert_eq!(Degree::Num(1), binomial.degree());
let monomial = LinearBinomial::new([0.0, 1.0]);
assert_eq!(Degree::Num(0), monomial.degree());
let zero = LinearBinomial::<i32>::zero();
assert_eq!(Degree::NegInf, zero.degree());

fn zero() -> Self

Returns a LinearBinomial with no terms.

Example

use rustnomial::{SizedPolynomial, LinearBinomial};
let zero = LinearBinomial::<i32>::zero();
assert!(zero.is_zero());
assert!(zero.ordered_term_iter().next().is_none());

fn set_to_zero(&mut self)

Sets self to zero.

Example

use rustnomial::{SizedPolynomial, LinearBinomial};
let mut non_zero = LinearBinomial::new([1, 1]);
assert!(!non_zero.is_zero());
non_zero.set_to_zero();
assert!(non_zero.is_zero());

fn terms_as_vec(&self) -> Vec<(N, usize)>

Returns a Vec containing all of the terms of self, where each item is the coefficient and degree of each non-zero term, in order of descending degree.

fn is_zero(&self) -> bool

Returns true if all terms of self are zero, and false if a non-zero term exists.

impl<N> Sub for LinearBinomial<N>

where N: Copy + Sub<Output = N>,

type Output = LinearBinomial<N>

The resulting type after applying the - operator.

fn sub(self, rhs: LinearBinomial<N>) -> LinearBinomial<N>

Performs the - operation.

impl<N> SubAssign for LinearBinomial<N>

where N: SubAssign + Copy,

fn sub_assign(&mut self, rhs: LinearBinomial<N>)

Performs the -= operation.