Struct FormalPowerSeries 

pub struct FormalPowerSeries { /* private fields */ }

A formal power series Σ a_k (x − point)^k with exact, lazily computed coefficients. See the module docs for the design.

Implementations

impl FormalPowerSeries

pub fn from_coefficients(var: &Ex, point: &Ex, coeffs: &[Ex]) -> Self

A polynomial series Σ coeffs[k] (var − point)^k from explicit coefficients (all in the same context as var).

Panics

Panics if the expressions come from different contexts.

use symplex::prelude::*;
use symplex::formal_series::FormalPowerSeries;

let ctx = Context::new();
let x = ctx.symbol("x");
let p = FormalPowerSeries::from_coefficients(&x, &ctx.int(0), &[ctx.int(1), ctx.int(2)]);
assert_eq!(p.truncate(5).to_string(), "2*x + 1");

pub fn variable(&self) -> Ex

The expansion variable.

pub fn point(&self) -> Ex

The expansion point.

pub fn context(&self) -> Context

The Context this series lives in.

pub fn coefficient(&self, k: usize) -> Ex

The k-th coefficient a_k as an exact expression.

For series with a pole at the expansion point this is the Laurent coefficient of (x − a)^k for k ≥ 0; use truncate to see the negative powers.

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
let s = x.sin().fps_maclaurin(&x);
assert_eq!(s.coefficient(3).to_string(), "-1/6");
assert_eq!(s.coefficient(4).to_string(), "0");

pub fn coefficient_rational(&self, k: usize) -> Option<Ratio<BigInt>>

The k-th coefficient as an exact rational, or None if it is not a rational number (e.g. ln 2, 2/√π, or a symbolic parameter).

pub fn coefficients(&self, n: usize) -> Vec<Ex>

The first n coefficients a_0 … a_{n−1}.

pub fn has_closed_form(&self) -> bool

Whether a closed-form general term is available (see general_term).

pub fn general_term(&self, k: &Ex) -> Option<Ex>

The general coefficient a_k as a closed-form expression in the symbolic index k, when known.

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
let k = ctx.symbol("k");
let e = x.exp().fps_maclaurin(&x);
assert_eq!(e.general_term(&k).unwrap().to_string(), "1/k!");

pub fn truncate(&self, n: usize) -> Ex

The truncated series Σ_{k<n} a_k (x − point)^k.

For series with a pole at the point, negative powers down to the pole order are included.

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
let s = x.cos().fps_maclaurin(&x);
assert_eq!(s.truncate(5).to_string(), "1/24*x^4 - 1/2*x^2 + 1");

pub fn add(&self, other: &Self) -> Result<Self, SymplexError>

self + other.

pub fn sub(&self, other: &Self) -> Result<Self, SymplexError>

self − other.

pub fn mul(&self, other: &Self) -> Result<Self, SymplexError>

Cauchy product self · other.

pub fn scale(&self, c: &Ex) -> Self

c · self for a constant c.

Panics

Panics if c belongs to a different context.

pub fn compose(&self, other: &Self) -> Result<Self, SymplexError>

Composition self(other); requires other to have zero constant term.

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
let e = x.exp().fps_maclaurin(&x);
let s = x.sin().fps_maclaurin(&x);
// exp(sin x) = 1 + x + x²/2 − x⁴/8 + …
let c = e.compose(&s).unwrap();
assert_eq!(c.truncate(5).to_string(), "-1/8*x^4 + 1/2*x^2 + x + 1");

pub fn derivative(&self) -> Self

Term-wise derivative d/dx.

pub fn integral(&self) -> Self

Term-wise antiderivative with zero constant term.

pub fn inverse(&self) -> Result<Self, SymplexError>

Multiplicative inverse 1/self; requires a non-zero constant term.

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
// 1/cos x = sec x = 1 + x²/2 + 5x⁴/24 + …
let sec = x.cos().fps_maclaurin(&x).inverse().unwrap();
assert_eq!(sec.truncate(5).to_string(), "5/24*x^4 + 1/2*x^2 + 1");

pub fn reversion(&self) -> Result<Self, SymplexError>

Compositional inverse (series reversion) by Lagrange inversion; requires a_0 = 0 and a_1 ≠ 0.

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
// reversion of sin is asin: x + x³/6 + 3x⁵/40
let asin = x.sin().fps_maclaurin(&x).reversion().unwrap();
assert_eq!(asin.truncate(6).to_string(), "3/40*x^5 + 1/6*x^3 + x");

Trait Implementations

impl Clone for FormalPowerSeries

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FormalPowerSeries

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

Formats the value using the given formatter.