Struct series::polyslice::PolynomialSlice

pub struct PolynomialSlice<'a, Var, C: Coeff> { /* fields omitted */ }

View into a Laurent polynomial

Methods

impl<'a, Var, C: Coeff> PolynomialSlice<'a, Var, C>

pub fn min_pow(&self) -> Option<isize>

Get the leading power of the polynomial variable

For vanishing polynomials None is returned

Example

use series::AsSlice;

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert_eq!(p.as_slice(..).min_pow(), Some(-1));
assert_eq!(p.as_slice(0..).min_pow(), Some(0));
let p = series::Polynomial::new("x", -1, vec![0]);
assert_eq!(p.as_slice(..).min_pow(), None);

pub fn max_pow(&self) -> Option<isize>

Get the highest power of the polynomial variable

For vanishing polynomials None is returned

Example

use series::AsSlice;

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert_eq!(p.as_slice(..).max_pow(), Some(1));
assert_eq!(p.as_slice(..1).max_pow(), Some(0));
let p = series::Polynomial::new("x", -1, vec![0]);
assert_eq!(p.max_pow(), None);

pub fn len(&self) -> usize

Get the difference between the highest and the lowest power of the polynomial variable

Example

use series::AsSlice;

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert_eq!(p.as_slice(..).len(), 3);
assert_eq!(p.as_slice(0..2).len(), 2);

pub fn is_empty(&self) -> bool

Check if the polynomial is zero

Example

use series::AsSlice;

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
assert!(!p.as_slice(..).is_empty());

let p = series::Polynomial::new("x", -1, vec!(0));
assert!(p.as_slice(..).is_empty());

pub fn coeff(&self, pow: isize) -> &C

pub fn iter(&self) -> Iter<C>

Iterator over the polynomial powers and coefficients.

Example

use series::AsSlice;

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
let slice = p.as_slice(..);
let mut iter = slice.iter();
assert_eq!(iter.next(), Some((-1, &1)));
assert_eq!(iter.next(), Some((0, &2)));
assert_eq!(iter.next(), Some((1, &3)));
assert_eq!(iter.next(), None);

pub fn split_at(&self, pos: isize) -> (Self, Self)

Split a polynomial slice into two at the given power of the polynomial variable.

Example

use series::AsSlice;

let p = series::Polynomial::new("x", -1, vec!(1,2,3));
let (lower, upper) = p.as_slice(..).split_at(0);
assert_eq!(lower.min_pow(), Some(-1));
assert_eq!(upper.min_pow(), Some(0));

Trait Implementations

impl<'a, Var: Clone, C: Coeff + Clone, Rhs> Add<Rhs> for PolynomialSlice<'a, Var, C> where
    Polynomial<Var, C>: AddAssign<Rhs>, 

type Output = Polynomial<Var, C>

The resulting type after applying the + operator.

fn add(self, other: Rhs) -> Self::Output

Performs the + operation.

impl<'a, Var: PartialEq + Debug, C: Coeff + Clone> AddAssign<PolynomialSlice<'a, Var, C>> for Polynomial<Var, C> where
    C: AddAssign<&'c C>, 

fn add_assign(&mut self, other: PolynomialSlice<'a, Var, C>)

Performs the += operation.

impl<'a, Var, C: Coeff> Clone for PolynomialSlice<'a, Var, C>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, Var, C: Coeff> Copy for PolynomialSlice<'a, Var, C>

impl<'a, Var: Debug, C: Debug + Coeff> Debug for PolynomialSlice<'a, Var, C>

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

Formats the value using the given formatter.

impl<'a, Var: Display, C: Coeff + Display> Display for PolynomialSlice<'a, Var, C>

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

Formats the value using the given formatter.

impl<'a, 'b, Var: Clone, C: Coeff> Div<&'b C> for PolynomialSlice<'a, Var, C> where
    &'c C: Div<Output = C>, 

type Output = Polynomial<Var, C>

The resulting type after applying the / operator.

fn div(self, scalar: &'b C) -> Self::Output

Performs the / operation.

impl<'a, Var: Clone, C: Coeff> Div<C> for PolynomialSlice<'a, Var, C> where
    &'c C: Div<Output = C>, 

type Output = Polynomial<Var, C>

The resulting type after applying the / operator.

fn div(self, scalar: C) -> Self::Output

Performs the / operation.

impl<'a, Var: Eq, C: Eq + Coeff> Eq for PolynomialSlice<'a, Var, C>

impl<'a, Var: Clone, C: Coeff + Clone> From<PolynomialSlice<'a, Var, C>> for Polynomial<Var, C>

fn from(s: PolynomialSlice<'a, Var, C>) -> Polynomial<Var, C>

Performs the conversion.

impl<'a, Var: Hash, C: Hash + Coeff> Hash for PolynomialSlice<'a, Var, C>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<'a, Var, C: Coeff> Index<isize> for PolynomialSlice<'a, Var, C>

type Output = C

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, 'b, Var: Clone, C: Coeff> KaratsubaMul<&'b Polynomial<Var, C>> for PolynomialSlice<'a, Var, C> where
    Var: Clone + PartialEq + Debug,
    C: Clone,
    C: AddAssign,
    Polynomial<Var, C>: AddAssign<&'c Polynomial<Var, C>> + SubAssign<&'c Polynomial<Var, C>>,
    Polynomial<Var, C>: AddAssign<Polynomial<Var, C>> + SubAssign<Polynomial<Var, C>>,
    PolynomialSlice<'c, Var, C>: Add<Output = Polynomial<Var, C>>,
    &'c C: Mul<Output = C>, 

type Output = Polynomial<Var, C>

fn karatsuba_mul(
    self,
    rhs: &'b Polynomial<Var, C>,
    min_size: usize
) -> Self::Output

Calculate self * rhs using Karatsuba multiplication.

impl<'a, 'b, Var: Clone, C: Coeff> KaratsubaMul<PolynomialSlice<'b, Var, C>> for PolynomialSlice<'a, Var, C> where
    Var: Clone + PartialEq + Debug,
    C: Clone,
    C: AddAssign,
    Polynomial<Var, C>: AddAssign<&'c Polynomial<Var, C>> + SubAssign<&'c Polynomial<Var, C>>,
    Polynomial<Var, C>: AddAssign<Polynomial<Var, C>> + SubAssign<Polynomial<Var, C>>,
    PolynomialSlice<'c, Var, C>: Add<Output = Polynomial<Var, C>>,
    &'c C: Mul<Output = C>, 

type Output = Polynomial<Var, C>

fn karatsuba_mul(
    self,
    rhs: PolynomialSlice<'b, Var, C>,
    min_size: usize
) -> Self::Output

Calculate self * rhs using Karatsuba multiplication.

impl<'a, 'b, Var: Clone, C: Coeff> KaratsubaMul<PolynomialSlice<'b, Var, C>> for &'a Polynomial<Var, C> where
    Var: Clone + PartialEq + Debug,
    C: Clone,
    C: AddAssign,
    Polynomial<Var, C>: AddAssign<&'c Polynomial<Var, C>> + SubAssign<&'c Polynomial<Var, C>>,
    Polynomial<Var, C>: AddAssign<Polynomial<Var, C>> + SubAssign<Polynomial<Var, C>>,
    PolynomialSlice<'c, Var, C>: Add<Output = Polynomial<Var, C>>,
    &'c C: Mul<Output = C>, 

type Output = Polynomial<Var, C>

fn karatsuba_mul(
    self,
    rhs: PolynomialSlice<'b, Var, C>,
    min_size: usize
) -> Self::Output

Calculate self * rhs using Karatsuba multiplication.

impl<'a, 'b, Var: Clone, C: Coeff> Mul<&'b C> for PolynomialSlice<'a, Var, C> where
    &'c C: Mul<Output = C>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, scalar: &'b C) -> Self::Output

Performs the * operation.

impl<'a, 'b, Var, C: Coeff> Mul<&'b Polynomial<Var, C>> for PolynomialSlice<'a, Var, C> where
    PolynomialSlice<'a, Var, C>: Mul<PolynomialSlice<'b, Var, C>, Output = Polynomial<Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, other: &'b Polynomial<Var, C>) -> Self::Output

Performs the * operation.

impl<'a, Var: Clone, C: Coeff> Mul<C> for PolynomialSlice<'a, Var, C> where
    &'b C: Mul<Output = C>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, scalar: C) -> Self::Output

Performs the * operation.

impl<'a, Var, C: Coeff> Mul<Polynomial<Var, C>> for PolynomialSlice<'a, Var, C> where
    PolynomialSlice<'a, Var, C>: Mul<PolynomialSlice<'b, Var, C>, Output = Polynomial<Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, other: Polynomial<Var, C>) -> Self::Output

Performs the * operation.

impl<'a, Var, C: Coeff> Mul<PolynomialSlice<'a, Var, C>> for Polynomial<Var, C> where
    Polynomial<Var, C>: MulAssign<PolynomialSlice<'a, Var, C>>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, other: PolynomialSlice<'a, Var, C>) -> Self::Output

Performs the * operation.

impl<'a, 'b, Var, C: Coeff> Mul<PolynomialSlice<'b, Var, C>> for PolynomialSlice<'a, Var, C> where
    Var: Clone + PartialEq + Debug,
    C: Clone,
    C: AddAssign,
    Polynomial<Var, C>: AddAssign<&'c Polynomial<Var, C>> + SubAssign<&'c Polynomial<Var, C>>,
    Polynomial<Var, C>: AddAssign<Polynomial<Var, C>> + SubAssign<Polynomial<Var, C>>,
    PolynomialSlice<'c, Var, C>: Add<Output = Polynomial<Var, C>>,
    &'c C: Mul<Output = C>, 

type Output = Polynomial<Var, C>

The resulting type after applying the * operator.

fn mul(self, other: PolynomialSlice<'b, Var, C>) -> Self::Output

Performs the * operation.

impl<'a, Var, C: Coeff> MulAssign<PolynomialSlice<'a, Var, C>> for Polynomial<Var, C> where
    PolynomialSlice<'b, Var, C>: Mul<PolynomialSlice<'a, Var, C>, Output = Polynomial<Var, C>>, 

fn mul_assign(&mut self, other: PolynomialSlice<'a, Var, C>)

Performs the *= operation.

impl<'a, Var: Clone, C: Coeff> Neg for PolynomialSlice<'a, Var, C> where
    &'c C: Neg<Output = C>, 

type Output = Polynomial<Var, C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, Var: Ord, C: Ord + Coeff> Ord for PolynomialSlice<'a, Var, C>

fn cmp(&self, other: &PolynomialSlice<'a, Var, C>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use] fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use] fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use] fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'a, Var: PartialEq, C: PartialEq + Coeff> PartialEq<PolynomialSlice<'a, Var, C>> for PolynomialSlice<'a, Var, C>

fn eq(&self, other: &PolynomialSlice<'a, Var, C>) -> bool

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

fn ne(&self, other: &PolynomialSlice<'a, Var, C>) -> bool

This method tests for !=.

impl<'a, Var: PartialOrd, C: PartialOrd + Coeff> PartialOrd<PolynomialSlice<'a, Var, C>> for PolynomialSlice<'a, Var, C>

fn partial_cmp(&self, other: &PolynomialSlice<'a, Var, C>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &PolynomialSlice<'a, Var, C>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &PolynomialSlice<'a, Var, C>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &PolynomialSlice<'a, Var, C>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &PolynomialSlice<'a, Var, C>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, Var, C: Coeff> StructuralEq for PolynomialSlice<'a, Var, C>

impl<'a, Var, C: Coeff> StructuralPartialEq for PolynomialSlice<'a, Var, C>

impl<'a, Var, C: Coeff, T> Sub<T> for PolynomialSlice<'a, Var, C> where
    C: Clone,
    Var: Clone,
    Polynomial<Var, C>: SubAssign<T>, 

type Output = Polynomial<Var, C>

The resulting type after applying the - operator.

fn sub(self, other: T) -> Self::Output

Performs the - operation.

impl<'a, Var, C: Coeff> SubAssign<PolynomialSlice<'a, Var, C>> for Polynomial<Var, C> where
    PolynomialSlice<'c, Var, C>: Neg<Output = Polynomial<Var, C>>,
    Polynomial<Var, C>: AddAssign<Polynomial<Var, C>>, 

fn sub_assign(&mut self, other: PolynomialSlice<'a, Var, C>)

Performs the -= operation.