Struct series::Series

pub struct Series<Var, C: Coeff> { /* fields omitted */ }

Laurent series in a single variable up to some power

Methods

impl<Var, C: Coeff> Series<Var, C>

pub fn new(var: Var, min_pow: isize, coeffs: Vec<C>) -> Series<Var, C>

Create a new series

Example

This creates a series in the variable "x", starting at "x"^-1 with coefficients 1, 2, 3. In other words, the series x^-1 + 2 + 3*x + O(x^2).

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

pub fn with_cutoff(
    var: Var,
    min_pow: isize,
    cutoff_pow: isize,
    coeffs: Vec<C>
) -> Series<Var, C>

Create a new series with a given cutoff power

Example

This creates a series in the variable "x", starting at "x"^-1 with coefficients 1, 2, 3. and vanishing coefficients up to "x"^5 .In other words, the series x^-1 + 2 + 3*x + O(x^5).

let s = series::Series::with_cutoff("x", -1, 5, vec!(1,2,3));

Panics

Panics if the cutoff power is lower than the starting power

pub fn var(&self) -> &Var

Get the expansion variable

Example

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

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

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

pub fn min_pow(&self) -> isize

Get the leading power of the series expansion variable

Example

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

pub fn cutoff_pow(&self) -> isize

Get the power of the expansion variable where the series is truncated, that is \( N \) in a series of the form \( \sum_{n=n_0}^{N-1} a_n x^n + O(x^N), \)

Example

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

impl<Var, C: Coeff> Series<Var, C>

pub fn powi(self, exp: i32) -> Self where
    C: DivAssign<&'a C>,
    &'a C: Mul<Output = C>,
    C: Clone + SubAssign + Ln<Output = C> + Div<Output = C> + Mul<Output = C>,
    Series<Var, C>: Mul<C, Output = Self> + Exp<Output = Self> + MulInverse<Output = Self>, 

Calculate series to some integer power

In contrast to the more general pow method this does not require the variable type to be convertible to the coefficient type and gives an overall nicer output

Example

let s = series::Series::new("x", -1, vec![1.,3.,7.]);
let s_to_minus_5 = series::Series::new("x", 5, vec![1.,-15.,100.]);
assert_eq!(s.powi(-5), s_to_minus_5);

Trait Implementations

impl<Var, C: Coeff> Ln for Series<Var, C> where
    C: DivAssign<&'a C>,
    &'a C: Mul<Output = C>,
    C: Clone + SubAssign + Add<Output = C> + Mul<Output = C> + Div<Output = C> + Ln<Output = C> + From<Var>,
    Var: Clone, 

type Output = Self

fn ln(self) -> Self

Computes the logarithm of a series

Panics

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

impl<'a, Var, C: Coeff> Ln for &'a Series<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<Var, C: Coeff> Exp for Series<Var, C> where
    &'a C: Mul<Output = C>,
    C: MulAssign<&'a C>,
    C: Clone + Div<Output = C> + Mul<Output = C> + AddAssign + Exp<Output = C>, 

type Output = Self

fn exp(self) -> Self::Output

Computes the exponential of a series

Panics

Panics if the series contains negative powers of the expansion variable

impl<'a, Var, C: Coeff> Exp for &'a Series<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

Computes the exponential of a series

Panics

Panics if the series contains negative powers of the expansion variable

impl<Var, C: Coeff, T> Pow<T> for Series<Var, C> where
    Series<Var, C>: Ln,
    <Series<Var, C> as Ln>::Output: Mul<T>,
    <<Series<Var, C> as Ln>::Output as Mul<T>>::Output: Exp, 

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

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

impl<'a, Var, C: Coeff, T> Pow<T> for &'a Series<Var, C> where
    &'b Series<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: Clone, C: Coeff + SubAssign> MulInverse for &'a Series<Var, C> where
    &'b C: Div<Output = C> + Mul<Output = C>, 

type Output = Series<Var, C>

fn mul_inverse(self) -> Self::Output

Compute 1/s for a series s

Example

use series::MulInverse;
let s = series::Series::new("x", -1, vec!(1.,2.,3.));
let s_inv = (&s).mul_inverse();
let one = series::Series::new("x", 0, vec!(1.,0.,0.));
assert_eq!(s * s_inv, one);

impl<Var: Clone, C: Coeff + SubAssign> MulInverse for Series<Var, C> where
    &'a Series<Var, C>: MulInverse<Output = Series<Var, C>>, 

type Output = Series<Var, C>

fn mul_inverse(self) -> Self::Output

Compute 1/s for a series s

Example

use series::MulInverse;
let s = series::Series::new("x", -1, vec!(1.,2.,3.));
let s_inv = s.clone().mul_inverse();
let one = series::Series::new("x", 0, vec!(1.,0.,0.));
assert_eq!(s * s_inv, one);

impl<Var: PartialOrd, C: PartialOrd + Coeff> PartialOrd<Series<Var, C>> for Series<Var, C>

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

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

fn lt(&self, other: &Series<Var, C>) -> bool

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

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

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

fn ge(&self, other: &Series<Var, C>) -> bool

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

impl<Var: PartialEq, C: PartialEq + Coeff> PartialEq<Series<Var, C>> for Series<Var, C>

fn eq(&self, other: &Series<Var, C>) -> bool

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

fn ne(&self, other: &Series<Var, C>) -> bool

This method tests for !=.

impl<Var, C: Coeff> From<Series<Var, C>> for SeriesParts<Var, C>

fn from(s: Series<Var, C>) -> Self

Performs the conversion.

impl<Var, C: Coeff> From<SeriesParts<Var, C>> for Series<Var, C>

fn from(parts: SeriesParts<Var, C>) -> Self

Performs the conversion.

impl<Var: Clone, C: Clone + Coeff> Clone for Series<Var, C>

fn clone(&self) -> Series<Var, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Var: Ord, C: Ord + Coeff> Ord for Series<Var, C>

fn cmp(&self, other: &Series<Var, C>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<Var: Eq, C: Eq + Coeff> Eq for Series<Var, C>

impl<Var: Display, C: Coeff + Display> Display for Series<Var, C>

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

Formats the value using the given formatter.

impl<Var: Debug, C: Debug + Coeff> Debug for Series<Var, C>

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

Formats the value using the given formatter.

impl<Var: Hash, C: Hash + Coeff> Hash for Series<Var, C>

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

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: Clone, C: Coeff + Clone, Rhs> Add<Rhs> for &'a Series<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<Var: Clone, C: Coeff + Clone, Rhs> Add<Rhs> for Series<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, C: Coeff, T> Sub<T> for &'a Series<Var, C> where
    Series<Var, C>: Clone + 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<Var, C: Coeff, T> Sub<T> for Series<Var, C> where
    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, T> Mul<T> for &'a Series<Var, C> where
    Series<Var, C>: Clone + MulAssign<T>, 

type Output = Series<Var, C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Var, C: Coeff, T> Mul<T> for Series<Var, C> where
    Series<Var, C>: MulAssign<T>, 

type Output = Series<Var, C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, Var, C: Coeff, T> Div<T> for &'a Series<Var, C> where
    Series<Var, C>: Clone + 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<Var, C: Coeff, T> Div<T> for Series<Var, C> where
    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<Var, C: Coeff + Neg<Output = C>> Neg for Series<Var, C>

type Output = Series<Var, C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Compute -s for a series s

Example

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

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

Compute -s for a series s

Example

let s = series::Series::new("x", -3, vec!(1.,0.,-3.));
let minus_s = series::Series::new("x", -3, vec!(-1.,0.,3.));
assert_eq!(-&s, minus_s);

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

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

Set s = s + t for two series s and t

Example

use series::Series;
let mut s = Series::new("x", -3, vec!(1.,0.,-3.));
let t = Series::new("x", -1, vec!(3., 4., 5.));
let res = Series::new("x", -3, vec!(1.,0.,0.));
s += &t;
assert_eq!(res, s);

Panics

Panics if the series have different expansion variables.

impl<Var, C: Coeff> AddAssign<Series<Var, C>> for Series<Var, C> where
    C: AddAssign<&'c C>,
    Var: PartialEq + Debug, 

fn add_assign(&mut self, other: Series<Var, C>)

Set s = s + t for two series s and t

Example

use series::Series;
let mut s = Series::new("x", -3, vec!(1.,0.,-3.));
let t = Series::new("x", -1, vec!(3., 4., 5.));
let res = Series::new("x", -3, vec!(1.,0.,0.));
s += t;
assert_eq!(res, s);

Panics

Panics if the series have different expansion variables.

impl<Var, C: Coeff + Clone> AddAssign<C> for Series<Var, C> where
    C: AddAssign<C>, 

fn add_assign(&mut self, rhs: C)

Performs the += operation.

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

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

Set s = s - t for two series s and t

Example

use series::Series;
let mut s = Series::new("x", -3, vec!(1.,0.,-3.));
let res = Series::new("x", 0, vec!());
s -= &s.clone();
assert_eq!(res, s);

Panics

Panics if the series have different expansion variables.

impl<Var, C: Coeff> SubAssign<Series<Var, C>> for Series<Var, C> where
    Series<Var, C>: AddAssign + Neg<Output = Series<Var, C>>, 

fn sub_assign(&mut self, other: Series<Var, C>)

Set s = s - t for two series s and t

Example

use series::Series;
let mut s = Series::new("x", -3, vec!(1.,0.,-3.));
let res = Series::new("x", 0, vec!());
s -= s.clone();
assert_eq!(res, s);

Panics

Panics if the series have different expansion variables.

impl<Var, C: Coeff + Clone> SubAssign<C> for Series<Var, C> where
    C: Neg<Output = C> + SubAssign<C>, 

fn sub_assign(&mut self, rhs: C)

Performs the -= operation.

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

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

Set s = s * t for two series s,t

Example

use series::Series;
let mut s = Series::new("x", -3, vec!(1.,0.,-3.));
s *= &s.clone();
let res = Series::new("x", -6, vec!(1.,0.,-6.));
assert_eq!(res, s);

Panics

Panics if the series have different expansion variables.

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

fn mul_assign(&mut self, other: Series<Var, C>)

Set s = s * t for two series s,t

Example

use series::Series;
let mut s = Series::new("x", -3, vec!(1.,0.,-3.));
s *= &s.clone();
let res = Series::new("x", -6, vec!(1.,0.,-6.));
assert_eq!(res, s);

Panics

Panics if the series have different expansion variables.

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

fn mul_assign(&mut self, rhs: &'a C)

Performs the *= operation.

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

fn mul_assign(&mut self, rhs: C)

Performs the *= operation.

impl<'a, Var: Clone, C: Coeff + SubAssign> DivAssign<&'a Series<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: &'a Series<Var, C>)

Sets s = s / t for two series s,t

Example

use series::Series;
let mut s = Series::new("x", -3, vec!(1.,0.,-3.));
s /= &s.clone();
let res = Series::new("x", 0, vec!(1.,0.,0.));
assert_eq!(res, s);

Panics

Panics if the series have different expansion variables.

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

fn div_assign(&mut self, other: Series<Var, C>)

Sets s = s / t for two series s,t

Example

use series::Series;
let mut s = Series::new("x", -3, vec!(1.,0.,-3.));
s /= s.clone();
let res = Series::new("x", 0, vec!(1.,0.,0.));
assert_eq!(res, s);

Panics

Panics if the series have different expansion variables.

impl<'a, Var, C: Coeff> DivAssign<&'a C> for Series<Var, C> where
    C: DivAssign<&'a C>, 

fn div_assign(&mut self, rhs: &'a C)

Performs the /= operation.

impl<Var, C: Coeff> DivAssign<C> for Series<Var, C> where
    Series<Var, C>: DivAssign<&'a C>, 

fn div_assign(&mut self, rhs: C)

Performs the /= operation.