Struct series::Series

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

Laurent series in a single variable up to some power

Implementations

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 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 max_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.max_pow(), 2);

Trait Implementations

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: PartialEq + Debug, C: Coeff + Clone> AddAssign<&'a Series<Var, C>> for Series<Var, C>where
    for<'c> 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 + Clone> AddAssign<C> for Series<Var, C>where
    C: AddAssign<C>,

fn add_assign(&mut self, rhs: C)

Performs the += operation.

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

fn div_assign(&mut self, rhs: C)

Performs the /= operation.

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

fn exp(self) -> Self::Output

Computes the exponential of a series

Panics

Panics if the series contains negative powers of the expansion variable

type Output = Series<Var, C>

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

fn exp(self) -> Self::Output

Computes the exponential of a series

Panics

Panics if the series contains negative powers of the expansion variable

type Output = Series<Var, C>

impl<Var: Hash, C: Hash + Coeff> Hash for Series<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,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

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

fn ln(self) -> Self::Output

Computes the logarithm of a series

Panics

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

type Output = Series<Var, C>

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

fn ln(self) -> Self

Computes the logarithm of a series

Panics

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

type Output = Series<Var, C>

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> MulAssign<&'a C> for Series<Var, C>where
    C: MulAssign<&'a C>,

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

Performs the *= operation.

impl<'a, Var: PartialEq + Debug, C: Coeff + Clone + AddAssign> MulAssign<&'a Series<Var, C>> for Series<Var, C>where
    for<'b> &'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<C> for Series<Var, C>where
    for<'a> Series<Var, C>: MulAssign<&'a C>,

fn mul_assign(&mut self, rhs: C)

Performs the *= operation.

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

type Output = Series<Var, C>

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

type Output = Series<Var, C>

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

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);

type Output = Series<Var, C>

The resulting type after applying the - operator.

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

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);

type Output = Series<Var, C>

The resulting type after applying the - operator.

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) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

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: &Rhs) -> bool

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

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: &Rhs) -> bool

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

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

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

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

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

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

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

impl<'a, 'b, Var, C: Coeff> Pow<&'a Series<Var, C>> for &'b Series<Var, C>where
    for<'c> &'c Series<Var, C>: Ln<Output = Series<Var, C>> + Mul<Series<Var, C>, Output = Series<Var, C>>,
    Series<Var, C>: Exp<Output = Series<Var, C>>,

fn pow(self, exponent: &'a Series<Var, C>) -> Self::Output

Computes s^t for two series s,t

Panics

Panics if the series have different expansion variables, s is zero, or t contains negative powers of the expansion variable

type Output = Series<Var, C>

impl<'a, Var, C: Coeff> Pow<&'a Series<Var, C>> for Series<Var, C>where
    for<'b> &'b Series<Var, C>: Mul<Series<Var, C>, Output = Series<Var, C>>,
    Series<Var, C>: Ln<Output = Self> + Exp<Output = Self>,

fn pow(self, exponent: &'a Series<Var, C>) -> Self

Computes s^t for two series s,t

Panics

Panics if the series have different expansion variables, s is zero, or t contains negative powers of the expansion variable

type Output = Series<Var, C>

impl<'a, Var, C: Coeff> Pow<Series<Var, C>> for &'a Series<Var, C>where
    for<'b> &'b Series<Var, C>: Ln<Output = Series<Var, C>>,
    Series<Var, C>: Exp<Output = Series<Var, C>> + Mul<Output = Series<Var, C>>,

fn pow(self, exponent: Series<Var, C>) -> Self::Output

Computes s^t for two series s,t

Panics

Panics if the series have different expansion variables, s is zero, or t contains negative powers of the expansion variable

type Output = Series<Var, C>

impl<Var, C: Coeff> Pow<Series<Var, C>> for Series<Var, C>where
    Series<Var, C>: Ln<Output = Self> + Exp<Output = Self> + Mul<Output = Self>,

fn pow(self, exponent: Series<Var, C>) -> Self

Computes s^t for two series s,t

Panics

Panics if the series have different expansion variables, s is zero, or t contains negative powers of the expansion variable

type Output = Series<Var, C>

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> SubAssign<&'a Series<Var, C>> for Series<Var, C>where
    for<'c> &'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 + 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<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: Eq, C: Eq + Coeff> Eq for Series<Var, C>

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

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