Skip to content
Symi Docs
Rust

The Rust manual covers the recommended facade. The complete native crate is documented in the native Rust API reference.

On this page

Series and residues

taylor_series#

api::Session method

pub fn taylor_series<'a, VariableType>(
    &self,
    target: &Expression,
    variable: VariableType,
    expansion_point: &Expression,
    truncation_order: usize,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,
Calling forms and variants

api::Expression method: api::Expression::taylor_series

pub fn taylor_series<'a, VariableType>(
    &self,
    variable: VariableType,
    expansion_point: &Expression,
    truncation_order: usize,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Variant using local assumptions — api::AssumptionScope method: api::AssumptionScope::taylor_series

pub fn taylor_series<'a, VariableType>(
    &self,
    target: &Expression,
    variable: VariableType,
    expansion_point: &Expression,
    truncation_order: usize,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Truncated Taylor expansion about expansion_point, keeping terms of degree strictly less than order (the remainder is O((x−a)order⁡)O((x-a)^{\operatorname{order}}). Returns the truncated polynomial, not a series object; order = 0 returns zero. Coefficients are computed exactly by repeated symbolic differentiation.

maclaurin_series#

api::analysis::Session method

pub fn maclaurin_series<'a, VariableType>(
    &self,
    input_expression: &Expression,
    variable: VariableType,
    truncation_order: usize,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,
Calling forms

api::expression_operations::Expression method: api::expression_operations::Expression::maclaurin_series

pub fn maclaurin_series<'a, VariableType>(
    &self,
    variable: VariableType,
    truncation_order: usize,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

taylor_series specialised to expansion point 0.

laurent_series#

api::Session method

pub fn laurent_series<'a, VariableType>(
    &self,
    target: &Expression,
    variable: VariableType,
    center: &Expression,
    order: usize,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,
Calling forms

api::Expression method: api::Expression::laurent_series

pub fn laurent_series<'a, VariableType>(
    &self,
    variable: VariableType,
    center: &Expression,
    order: usize,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Truncated Laurent expansion at center: every (variable⁡−center⁡)k(\operatorname{variable} - \operatorname{center})^k term with −m≤k<order⁡-m \le k < \operatorname{order}, where m is the pole order. Analytic points degrade to the Taylor expansion. At an essential singularity (where pole_order declines) the result is an unevaluated series_unevaluated(...) placeholder, because no finite truncation of the principal part is correct.

residue#

api::analysis::Session method

pub fn residue<'a, VariableType>(
    &self,
    input_expression: &Expression,
    variable: VariableType,
    center: &Expression,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,
Calling forms

api::expression_operations::Expression method: api::expression_operations::Expression::residue

pub fn residue<'a, VariableType>(
    &self,
    variable: VariableType,
    center: &Expression,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Coefficient of (variable⁡−center⁡)−1(\operatorname{variable} - \operatorname{center})^{-1} in the Laurent expansion at center. Analytic/removable points give 0; simple poles use the limit of (x−c)f(x - c) f; higher poles use the derivative formula. Essential singularities return an unevaluated residue_unevaluated(...) placeholder. Rational functions use exact polynomial valuations and formal series division, so explicit algebraic centers do not need to occur as structural factors.

pole_order#

api::analysis::Session method

pub fn pole_order<'a, VariableType>(
    &self,
    input_expression: &Expression,
    variable: VariableType,
    center: &Expression,
) -> Result<Option<i64>, ApiError>
where
    VariableType: Into<VariableLike<'a>>,
Calling forms

api::expression_operations::Expression method: api::expression_operations::Expression::pole_order

pub fn pole_order<'a, VariableType>(
    &self,
    variable: VariableType,
    center: &Expression,
) -> Result<Option<i64>, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Order of the singularity at center: 0 for analytic/removable points, m≥1m \ge 1 for a pole of order mm. Returns None (undefined in JS) when no order ≤16\leq 16 can be certified — the essential-singularity / undecidable verdict. Notes: this is the one series entry returning a plain integer, mirroring the core classifier; it never returns an unevaluated form. For a rational function at an exact algebraic center, the order is obtained from the square-free multiplicities of its numerator and denominator.

Example#

This family is not part of the recommended symi::api facade in this release. Call it through the native modules in the native Rust API reference.