Struct series::slice::SeriesSlice

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

View into a Laurent series

Methods

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

pub fn min_pow(&self) -> isize

Get the leading power of the series expansion variable

Example

use series::AsSlice;

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

pub fn cutoff_pow(&self) -> isize

Get the power of the expansion variable where the slice is truncated.

Example

use series::AsSlice;

let s = series::Series::new("x", -1, vec!(1,2,3));
assert_eq!(s.as_slice(..).cutoff_pow(), 2);
assert_eq!(s.as_slice(..1).cutoff_pow(), 1);

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

Get the series coefficient of the expansion variable to the given power.

Returns None if the requested power is above the highest known power. Coefficients below the leading power are zero.

Example

use series::AsSlice;

let s = series::Series::new("x", -1, vec!(1,2,3));
let slice = s.as_slice(..);
assert_eq!(slice.coeff(-5), Some(&0));
assert_eq!(slice.coeff(-2), Some(&0));
assert_eq!(slice.coeff(-1), Some(&1));
assert_eq!(slice.coeff(0), Some(&2));
assert_eq!(slice.coeff(1), Some(&3));
assert_eq!(slice.coeff(2), None);
assert_eq!(slice.coeff(5), None);

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

Iterator over the series powers and coefficients.

Example

use series::AsSlice;

let s = series::Series::new("x", -1, vec!(1,2,3));
let slice = s.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 series slice into two at the given power of the expansion variable.

Example

use series::AsSlice;

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

pub fn as_poly(&self) -> PolynomialSlice<'a, Var, C>

View as polynomial slice

Example

use series::AsSlice;

let s = series::Series::new("x", -1, vec!(1,2,3));
let slice = s.as_slice(..).as_poly();
let p = series::Polynomial::from(s.clone());
assert_eq!(slice, p.as_slice(..));

Trait Implementations

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

type Output = Series<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<SeriesSlice<'a, Var, C>> for Series<Var, C> where
    C: AddAssign<&'c C>, 

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

Performs the += operation.

impl<'a, Var, C: Coeff> Clone for SeriesSlice<'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 SeriesSlice<'a, Var, C>

impl<'a, Var: Debug, C: Debug + Coeff> Debug for SeriesSlice<'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 SeriesSlice<'a, Var, C>

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

Formats the value using the given formatter.

impl<'a, Var, C: Coeff, T> Div<T> for SeriesSlice<'a, Var, C> where
    Var: Clone,
    C: Clone,
    Series<Var, C>: DivAssign<T>, 

type Output = Series<Var, C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, Var: Clone, C: Coeff + SubAssign> DivAssign<SeriesSlice<'a, Var, C>> for Series<Var, C> where
    Series<Var, C>: MulAssign,
    &'b C: Div<Output = C> + Mul<Output = C>,
    &'c Series<Var, C>: MulInverse<Output = Series<Var, C>>, 

fn div_assign(&mut self, other: SeriesSlice<'a, Var, C>)

Performs the /= operation.

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

impl<'a, Var, C: Coeff> Exp for SeriesSlice<'a, Var, C> where
    &'b C: Mul<Output = C>,
    C: MulAssign<&'b C>,
    Var: Clone,
    C: Clone + Div<Output = C> + Mul<Output = C> + AddAssign + Exp<Output = C>, 

type Output = Series<Var, C>

fn exp(self) -> Self::Output

impl<'a, Var: Clone, C: Coeff + Clone> From<SeriesSlice<'a, Var, C>> for Series<Var, C>

fn from(s: SeriesSlice<'a, Var, C>) -> Self

Performs the conversion.

impl<'a, Var: Hash, C: Hash + Coeff> Hash for SeriesSlice<'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 SeriesSlice<'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, Var, C: Coeff> Ln for SeriesSlice<'a, Var, C> where
    C: Div<&'b C, Output = C>,
    &'b C: Mul<Output = C> + Ln<Output = C>,
    C: Clone + SubAssign + Add<Output = C> + Mul<Output = C> + Div<Output = C> + From<Var>,
    Var: Clone, 

type Output = Series<Var, C>

fn ln(self) -> Self::Output

Computes the logarithm of a series

Panics

Panics if the series has no (non-zero) coefficients

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

type Output = Series<Var, C>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Series<Var, C>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Series<Var, C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, Var, C: Coeff> Mul<Series<Var, C>> for SeriesSlice<'a, Var, C> where
    Var: Clone,
    C: Clone,
    Series<Var, C>: MulAssign<Series<Var, C>>, 

type Output = Series<Var, C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, Var, C: Coeff> Mul<SeriesSlice<'a, Var, C>> for Series<Var, C> where
    Series<Var, C>: MulAssign<SeriesSlice<'a, Var, C>>, 

type Output = Series<Var, C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, Var, C: Coeff> Mul<SeriesSlice<'a, Var, C>> for SeriesSlice<'a, Var, C> where
    Var: Clone,
    C: Clone,
    Series<Var, C>: Mul<SeriesSlice<'a, Var, C>, Output = Series<Var, C>>, 

type Output = Series<Var, C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, Var, C> MulAssign<SeriesSlice<'a, Var, C>> for Series<Var, C> where
    Var: PartialEq + Debug,
    &'b C: Mul<Output = C>,
    C: MulAssign<&'a C> + Coeff + Clone + AddAssign, 

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

Performs the *= operation.

impl<'a, Var, C> MulInverse for SeriesSlice<'a, Var, C> where
    Var: Clone,
    C: Coeff + SubAssign,
    &'b C: Div<Output = C> + Mul<Output = C>, 

type Output = Series<Var, C>

fn mul_inverse(self) -> Self::Output

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

type Output = Series<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 SeriesSlice<'a, Var, C>

fn cmp(&self, other: &SeriesSlice<'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<SeriesSlice<'a, Var, C>> for SeriesSlice<'a, Var, C>

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

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

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

This method tests for !=.

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

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

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

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

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

fn le(&self, other: &SeriesSlice<'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: &SeriesSlice<'a, Var, C>) -> bool

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

fn ge(&self, other: &SeriesSlice<'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, T> Pow<T> for SeriesSlice<'a, Var, C> where
    SeriesSlice<'b, Var, C>: Ln<Output = Series<Var, C>>,
    Series<Var, C>: Mul<T>,
    <Series<Var, C> as Mul<T>>::Output: Exp, 

type Output = <<Series<Var, C> as Mul<T>>::Output as Exp>::Output

fn pow(self, exponent: T) -> Self::Output

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

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

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

type Output = Series<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<SeriesSlice<'a, Var, C>> for Series<Var, C> where
    SeriesSlice<'c, Var, C>: Neg<Output = Series<Var, C>>,
    Series<Var, C>: AddAssign<Series<Var, C>>, 

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

Performs the -= operation.