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

Special functions

Special functions retain their symbolic form when a closed expression is not available.

Gamma family#

The first-tier gamma special functions. Symbolic special values, the non-positive-integer poles, the recurrence/reflection identities, and arbitrary-precision numeric evaluation (real and complex) all apply.

gamma#

api::Session method

pub fn gamma(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>
Calling forms

api::Expression method: api::Expression::gamma

pub fn gamma(&self) -> Result<Expression, ApiError>

The gamma function Γ(x)\Gamma(x), the analytic continuation of (x-1)!.

log_gamma#

api::Session method

pub fn log_gamma(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>
Calling forms

api::Expression method: api::Expression::log_gamma

pub fn log_gamma(&self) -> Result<Expression, ApiError>

The principal-branch log-gamma function (not log(gamma(x)) off the real axis).

digamma#

api::Session method

pub fn digamma(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>
Calling forms

api::Expression method: api::Expression::digamma

pub fn digamma(&self) -> Result<Expression, ApiError>

The digamma function ψ(x)=Γ′(x)/Γ(x)\psi(x) = \Gamma'(x)/\Gamma(x).

polygamma#

api::Session method

pub fn polygamma(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The polygamma function ψ(n)(x)\psi^{(n)}(x), the order-th derivative of digamma; polygamma(0, x) reduces to digamma(x).

beta#

api::Session method

pub fn beta(
    &self,
    left: &Expression,
    right: &Expression,
) -> Result<Expression, ApiError>

The beta function B⁡(x,y)=Γ(x)Γ(y)/Γ(x+y)\operatorname{B}(x, y) = \Gamma(x)\Gamma(y)/\Gamma(x+y).

zeta#

api::Session method

pub fn zeta(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Riemann zeta function ζ(s)=∑k≥1k−s\zeta(s) = \sum_{k\geq 1} k^{-s}. Even positive integers fold to the π\pi closed forms (zeta(2) = pi^2/6, zeta(4) = pi^4/90, …), zeta(0) = -1/2, negative integers to their rational functional values (zeta(-1) = -1/12, zeta(-2n) = 0); zeta(1) is the simple pole (undefined). Odd positive integers (zeta(3), …) stay the symbolic head; every value evaluates to arbitrary precision over R\mathbb{R} and C\mathbb{C}.

hurwitz_zeta#

api::Session method

pub fn hurwitz_zeta(
    &self,
    s: &Expression,
    a: &Expression,
) -> Result<Expression, ApiError>

The Hurwitz zeta function ζ(s,a)=∑k≥0(k+a)−s\zeta(s, a) = \sum_{k\geq 0} (k+a)^{-s}, the numeric primitive of the family. hurwitz_zeta(s, 1) folds to zeta(s); hurwitz_zeta(s, 1/2) to (2s−1)ζ(s)(2^s - 1)\zeta(s); a positive integer second argument reduces to zeta(s) minus the finite head; a non-positive integer first argument gives a Bernoulli polynomial in a.

polylogarithm#

api::Session method

pub fn polylogarithm(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The principal-branch polylogarithm Li⁡s(z)\operatorname{Li}_s(z). The defining-series values polylogarithm(s, 0) = 0, polylogarithm(s, 1) = zeta(s) for integer s > 1, and polylogarithm(1, z) = -log(1-z) reduce exactly. polylogarithm(2, 1/2) uses the branch-safe real dilogarithm reflection identity and reduces to pi^2/12 - log(2)^2/2. At -1 the alternating value polylogarithm(s, -1) = (2^(1-s) - 1) zeta(s) reduces exactly for integer s > 1, so polylogarithm(2, -1) = -pi^2/12. Numeric evaluation uses defining and near-one series in their certified regions, the series in log⁡z\log z on the annulus about the unit circle that the other routes do not reach, Hurwitz-zeta continuation for general exterior orders, and a bounded Bernoulli inversion formula for positive integer orders. Regions outside those certified routes decline numerically rather than returning a low-confidence value.

lerch_phi#

api::Session method

pub fn lerch_phi(
    &self,
    argument: &Expression,
    order: &Expression,
    shift: &Expression,
) -> Result<Expression, ApiError>

The principal Lerch transcendent Φ(z,s,a)\Phi(z, s, a), whose canonical argument order is (argument, order, shift). Numeric evaluation uses the defining and near-one continuation kernels where their hypotheses hold. Exact nonpositive integer shifts are normalized through the finite-prefix recurrence before those kernels are selected; other unsupported continuation regions decline numerically.

Error function and Fresnel integrals#

These are the entire, odd functions obtained by integrating a Gaussian kernel from the origin. Each one vanishes at zero, reflects a negated argument out as an overall sign, and evaluates to arbitrary precision over R\mathbb{R} and C\mathbb{C} through its hypergeometric representation. They are the primitives indefinite integration closes onto when no elementary antiderivative exists: exp(a*x^2 + b*x + c) integrates to error_function for a proved negative a and to imaginary_error_function for a proved positive a, and sin or cos of a quadratic with a leading coefficient of proved sign integrates to the Fresnel integrals. A leading coefficient whose sign is not proved declines.

error_function#

api::Session method

pub fn error_function(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The error function erf⁡(x)=2π∫0xe−t2 dt\operatorname{erf}(x) = \frac{2}{\sqrt{\pi}}\int_0^x e^{-t^2}\,dt. error_function(0) = 0 and the values at ±∞\pm\infty are ±1\pm 1.

error_function_complementary#

api::Session method

pub fn error_function_complementary(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The complementary error function erfc⁡(x)=1−erf⁡(x)\operatorname{erfc}(x) = 1 - \operatorname{erf}(x).

imaginary_error_function#

api::Session method

pub fn imaginary_error_function(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The imaginary error function erfi⁡(x)=2π∫0xet2 dt=−ierf⁡(ix)\operatorname{erfi}(x) = \frac{2}{\sqrt{\pi}}\int_0^x e^{t^2}\,dt = -i\operatorname{erf}(ix), with derivative 2πex2\frac{2}{\sqrt{\pi}} e^{x^2}. It is real on the real line and grows without bound towards ±∞\pm\infty.

fresnel_sine_integral#

api::Session method

pub fn fresnel_sine_integral(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Fresnel sine integral S(x)=∫0xsin⁡(πt2/2) dtS(x) = \int_0^x \sin(\pi t^2/2)\,dt in the normalization of DLMF §\S7.2(iv), so S′(x)=sin⁡(πx2/2)S'(x) = \sin(\pi x^2/2) and S(±∞)=±1/2S(\pm\infty) = \pm 1/2.

fresnel_cosine_integral#

api::Session method

pub fn fresnel_cosine_integral(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Fresnel cosine integral C(x)=∫0xcos⁡(πt2/2) dtC(x) = \int_0^x \cos(\pi t^2/2)\,dt, with C′(x)=cos⁡(πx2/2)C'(x) = \cos(\pi x^2/2) and C(±∞)=±1/2C(\pm\infty) = \pm 1/2.

Exponential, sine, cosine, and logarithmic integrals#

These are the special functions indefinite integration closes onto for exp(x)/x, sin(x)/x, cos(x)/x, and 1/log(x). They are symbolic heads with exact derivatives; numeric evaluation of them is not implemented and declines rather than returning a value.

exponential_integral#

api::Session method

pub fn exponential_integral(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The exponential integral Ei⁡(x)\operatorname{Ei}(x), with Ei⁡′(x)=ex/x\operatorname{Ei}'(x) = e^x/x.

sine_integral#

api::Session method

pub fn sine_integral(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The sine integral Si⁡(x)=∫0xsin⁡(t)/t dt\operatorname{Si}(x) = \int_0^x \sin(t)/t\,dt. sine_integral(0) = 0 and sine_integral(infinity) = pi/2.

cosine_integral#

api::Session method

pub fn cosine_integral(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The cosine integral Ci⁡(x)\operatorname{Ci}(x), with Ci⁡′(x)=cos⁡(x)/x\operatorname{Ci}'(x) = \cos(x)/x.

logarithmic_integral#

api::Session method

pub fn logarithmic_integral(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The logarithmic integral li⁡(x)\operatorname{li}(x), with li⁡′(x)=1/log⁡(x)\operatorname{li}'(x) = 1/\log(x).

Generalized hypergeometric family#

Symi implements the ordinary pFq{}_pF_q, not the regularized (Olver-normalized) form.

Both parameter groups are ordered sequences: order and repetition are significant, because p and q are the group lengths and a repeated parameter changes the function. A Python set or frozenset is rejected; pass a list or tuple. An empty group is valid and is how 0F0 and 0F1 are written.

A call terminates into an exact polynomial when an upper parameter is a non-positive integer. The lower parameters must avoid the non-positive integers, because those make a Pochhammer denominator vanish; when a lower parameter is a non-positive integer but the series terminates strictly before that denominator is reached, the polynomial is still well defined and is returned. An uncancelled denominator singularity gives undefined.

Numeric evaluation sums the defining series where DLMF 16.2 guarantees convergence: everywhere for p≤qp \leq q, and strictly inside the unit disk with a margin for p=q+1p = q+1. Beyond that disk the Gauss function 2F1{}_2F_1 is continued through three principal-branch transformations — Pfaff's (DLMF 15.8.1), the expansion in 1−z1-z (DLMF 15.8.4), and the expansion in 1/z1/z (DLMF 15.8.2) — and the confluent function 1F1{}_1F_1 uses Kummer's transformation (DLMF 13.2.39) for a negative real part, where the direct terms alternate and lose digits to cancellation. The route is chosen deterministically from the parameters and the argument.

Evaluation declines rather than returning a value whenever:

  • the nonterminating p>q+1p > q+1 series is divergent — it is not assigned a value by a hidden summability convention;
  • an argument lies on, or indistinguishably near, the principal cut from 11 to +∞+\infty, where the function has two different boundary values;
  • a continuation's parameter combination is at or near an integer, the resonance at which the two solutions coincide and the true expansion acquires logarithmic terms;
  • no implemented route covers the region — a general pFqpF_q with p=q+1p = q+1 outside its disk, for instance, has no continuation in this release.

A returned value is accepted only when two evaluations at different working precisions agree to the precision that was requested, so a result hollowed out by cancellation declines instead of being reported. Exact simplification never falls back to a numeric result.

error_function and error_function_complementary are evaluated through their DLMF 7.11.1 confluent representation, which gives them the same arbitrary-precision complex behaviour.

Exact reductions that run automatically are limited to the globally safe ones — 0F0{}_0F_0 to the exponential, a zero argument to one, safe parameter cancellation, terminating expansion within a size budget — plus Gauss's summation at z=1z = 1 (DLMF 15.4.20) when ℜ(c−a−b)>0\Re(c-a-b) > 0 is proved; with the condition unproved the call stays symbolic, because the series there genuinely diverges when it fails.

hypergeometric_pfq#

api::Session method

pub fn hypergeometric_pfq<UpperType, LowerType>(
    &self,
    upper_parameters: UpperType,
    lower_parameters: LowerType,
    argument: &Expression,
) -> Result<Expression, ApiError>
where
    UpperType: IntoIterator<Item = Expression>,
    LowerType: IntoIterator<Item = Expression>,

The generalized hypergeometric function pFq(a;b;z){}_pF_q(\mathbf a; \mathbf b; z). The two parameter groups are ordered sequences: order and repetition are significant, so a set or frozenset is rejected.

hypergeometric_0f1#

api::Session method

pub fn hypergeometric_0f1(
    &self,
    lower_parameter: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The confluent limit 0F1(;b;z){}_0F_1(; b; z), lowered to hypergeometric_pfq.

hypergeometric_1f1#

api::Session method

pub fn hypergeometric_1f1(
    &self,
    upper_parameter: &Expression,
    lower_parameter: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

Kummer's confluent hypergeometric function 1F1(a;b;z){}_1F_1(a; b; z).

hypergeometric_2f1#

api::Session method

pub fn hypergeometric_2f1(
    &self,
    first_upper_parameter: &Expression,
    second_upper_parameter: &Expression,
    lower_parameter: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Gauss hypergeometric function 2F1(a,b;c;z){}_2F_1(a, b; c; z).

Meijer G-function#

meijer_g#

api::Session method

pub fn meijer_g<FirstType, SecondType, ThirdType, FourthType>(
    &self,
    upper_numerator_parameters: FirstType,
    upper_denominator_parameters: SecondType,
    lower_numerator_parameters: ThirdType,
    lower_denominator_parameters: FourthType,
    argument: &Expression,
) -> Result<Expression, ApiError>
where
    FirstType: IntoIterator<Item = Expression>,
    SecondType: IntoIterator<Item = Expression>,
    ThirdType: IntoIterator<Item = Expression>,
    FourthType: IntoIterator<Item = Expression>,

The Meijer G-function Gp,qm,nG_{p,q}^{m,n} from its four ordered parameter groups. The orders m, n, p, and q are read from the group lengths and are never supplied separately.

The four groups follow the DLMF 16.17 partition: the first n upper parameters, the remaining p - n upper parameters, the first m lower parameters, and the remaining q - m lower parameters. Any group may be empty.

A configuration in which some upper-numerator parameter minus some lower-numerator parameter is a positive integer has colliding pole families and no separating contour, and gives undefined. General Mellin–Barnes contour construction and evaluation are outside this release: a syntactically valid call whose contour conditions are unsettled stays a symbolic head, and numeric evaluation of it declines.

The one route into and out of the G head is the residue expansion of DLMF 16.17.2, which writes the call as a finite sum of pFq−1{}_pF_{q-1} terms. It applies when p<qp < q, or p=qp = q with the argument strictly inside the unit disk, and when no two of the first mm lower parameters differ by an integer — at an integer difference the poles merge and the true expansion carries logarithms, so the reduction declines instead. Numeric evaluation of a Meijer-G call runs through exactly that reduction and declines when it does not apply.

The reduction and its inverse are directed rewrites, requested through the special-function basis rather than applied automatically:

  • generalized_hypergeometric reduces an eligible meijer_g call to its finite pFq{}_pF_q sum, and rewrites error_function into its DLMF 7.11.1 confluent form;
  • meijer_g rewrites a pFq{}_pF_q call into the single G function of DLMF 16.18.1 with its gamma prefactor, declining when a parameter sits on a pole of its own gamma factor.

Bessel, Hankel, spherical-Bessel, and Airy families#

The cylinder functions use their principal branches. bessel_j and bessel_i become entire in their argument at proved integer order; bessel_y, bessel_k, and the Hankel functions retain their principal cut. Spherical functions require a nonnegative integer order and do not inherit a spurious cut from their half-integer cylinder representation. Airy functions are entire.

bessel_j#

api::Session method

pub fn bessel_j(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The principal Bessel function Jν(z)J_\nu(z).

bessel_y#

api::Session method

pub fn bessel_y(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The principal Bessel function Yν(z)Y_\nu(z).

bessel_i#

api::Session method

pub fn bessel_i(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The principal modified Bessel function Iν(z)I_\nu(z).

bessel_k#

api::Session method

pub fn bessel_k(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The principal modified Bessel function Kν(z)K_\nu(z).

hankel_first_kind#

api::Session method

pub fn hankel_first_kind(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The principal Hankel function Hν(1)(z)H_\nu^{(1)}(z).

hankel_second_kind#

api::Session method

pub fn hankel_second_kind(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The principal Hankel function Hν(2)(z)H_\nu^{(2)}(z).

spherical_bessel_j#

api::Session method

pub fn spherical_bessel_j(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The spherical Bessel function jn(z)\mathsf j_n(z), for n∈N0n\in\mathbb N_0.

spherical_bessel_y#

api::Session method

pub fn spherical_bessel_y(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The spherical Bessel function yn(z)\mathsf y_n(z), for n∈N0n\in\mathbb N_0.

spherical_hankel_first_kind#

api::Session method

pub fn spherical_hankel_first_kind(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The spherical Hankel function hn(1)(z)\mathsf h_n^{(1)}(z), for n∈N0n\in\mathbb N_0.

spherical_hankel_second_kind#

api::Session method

pub fn spherical_hankel_second_kind(
    &self,
    order: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The spherical Hankel function hn(2)(z)\mathsf h_n^{(2)}(z), for n∈N0n\in\mathbb N_0.

airy_ai#

api::Session method

pub fn airy_ai(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Airy function Ai⁡(z)\operatorname{Ai}(z).

airy_bi#

api::Session method

pub fn airy_bi(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Airy function Bi⁡(z)\operatorname{Bi}(z).

airy_ai_prime#

api::Session method

pub fn airy_ai_prime(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The derivative Ai⁡′(z)\operatorname{Ai}'(z).

airy_bi_prime#

api::Session method

pub fn airy_bi_prime(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

The derivative Bi⁡′(z)\operatorname{Bi}'(z).

Classical orthogonal polynomials#

Every family in this group is the classical polynomial sequence at a non-negative integer degree, following DLMF Chapter 18. A degree proved not to be a non-negative integer gives undefined, and a degree that cannot be classified leaves the call symbolic. Once the degree is admissible the value is a finite polynomial and therefore entire in its argument, whatever the family parameters are: the orthogonality hypotheses α>−1\alpha>-1, β>−1\beta>-1, and λ>−1/2\lambda>-1/2 are conditions of the weighted-inner-product theorems, not conditions for the polynomial to have a value. hermite_polynomial is the physicists' HnH_n.

A literal degree up to 1024 at an exact rational argument, with exact rational family parameters, evaluates to its exact rational value: chebyshev_polynomial_first_kind(10, 1/2) is -1/2. At any other argument the named head stays as it is until expand_orthogonal_polynomial is asked for.

jacobi_polynomial#

api::Session method

pub fn jacobi_polynomial(
    &self,
    degree: &Expression,
    first_parameter: &Expression,
    second_parameter: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Jacobi polynomial Pn(α,β)(x)P_n^{(\alpha,\beta)}(x).

gegenbauer_polynomial#

api::Session method

pub fn gegenbauer_polynomial(
    &self,
    degree: &Expression,
    parameter: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Gegenbauer polynomial Cn(λ)(x)C_n^{(\lambda)}(x).

chebyshev_polynomial_first_kind#

api::Session method

pub fn chebyshev_polynomial_first_kind(
    &self,
    degree: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Chebyshev polynomial of the first kind Tn(x)T_n(x).

chebyshev_polynomial_second_kind#

api::Session method

pub fn chebyshev_polynomial_second_kind(
    &self,
    degree: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Chebyshev polynomial of the second kind Un(x)U_n(x).

legendre_polynomial#

api::Session method

pub fn legendre_polynomial(
    &self,
    degree: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Legendre polynomial Pn(x)P_n(x).

generalized_laguerre_polynomial#

api::Session method

pub fn generalized_laguerre_polynomial(
    &self,
    degree: &Expression,
    parameter: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The generalized Laguerre polynomial Ln(α)(x)L_n^{(\alpha)}(x).

hermite_polynomial#

api::Session method

pub fn hermite_polynomial(
    &self,
    degree: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The physicists' Hermite polynomial Hn(x)H_n(x).

ultraspherical_polynomial#

api::Session method

pub fn ultraspherical_polynomial(
    &self,
    degree: &Expression,
    parameter: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The ultraspherical polynomial, lowered to its canonical Gegenbauer head.

laguerre_polynomial#

api::Session method

pub fn laguerre_polynomial(
    &self,
    degree: &Expression,
    argument: &Expression,
) -> Result<Expression, ApiError>

The Laguerre polynomial, lowered to its canonical generalized Laguerre head.

Example#

Special functions reduce at recognised arguments.

Rust
use symi::api::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let session = Session::new();

    println!("{}", session.gamma(&session.rational(1, 2)?)?);
    println!("{}", session.zeta(&session.integer(2))?);
    println!("{}", session.beta(&session.integer(2), &session.integer(3))?);
    println!("{}", session.digamma(&session.integer(1))?);
    Ok(())
}

convert_polynomial_basis#

api::Session method

pub fn convert_polynomial_basis<'a, VariableType>(
    &self,
    target: &Expression,
    variable: VariableType,
    basis: &OrthogonalPolynomialBasis,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,
Calling forms

api::Expression method: api::Expression::convert_polynomial_basis

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

Express a finite univariate polynomial in a classical orthogonal basis — as a combination of Chebyshev, Legendre, Hermite, Laguerre, Gegenbauer, or Jacobi polynomials rather than powers of the variable. The conversion is exact; a target that is not a finite univariate polynomial in variable declines.

orthogonal_polynomial_coefficient#

api::Session method

pub fn orthogonal_polynomial_coefficient<'a, VariableType>(
    &self,
    target: &Expression,
    variable: VariableType,
    basis: &OrthogonalPolynomialBasis,
    degree: usize,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,
Calling forms

api::Expression method: api::Expression::orthogonal_polynomial_coefficient

pub fn orthogonal_polynomial_coefficient<'a, VariableType>(
    &self,
    variable: VariableType,
    basis: &OrthogonalPolynomialBasis,
    degree: usize,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

One exact coefficient of that expansion, without forming the whole of it: the coefficient of the basis polynomial of the given degree.

expand_orthogonal_polynomial#

api::Session method

pub fn expand_orthogonal_polynomial(
    &self,
    target: &Expression,
) -> Result<Expression, ApiError>
Calling forms

api::Expression method: api::Expression::expand_orthogonal_polynomial

pub fn expand_orthogonal_polynomial(
    &self,
) -> Result<Expression, ApiError>

The inverse direction: expand every classical orthogonal polynomial call in the expression into an ordinary polynomial in its variable.

Additional API#

carlson_rc#

api::Session method

pub fn carlson_rc(
    &self,
    first_argument: &Expression,
    second_argument: &Expression,
) -> Result<Expression, ApiError>

Carlson's degenerate symmetric elliptic integral RC(x,y)R_C(x,y).

carlson_rd#

api::Session method

pub fn carlson_rd(
    &self,
    first_argument: &Expression,
    second_argument: &Expression,
    third_argument: &Expression,
) -> Result<Expression, ApiError>

Carlson's symmetric elliptic integral RD(x,y,z)R_D(x,y,z).

carlson_rf#

api::Session method

pub fn carlson_rf(
    &self,
    first_argument: &Expression,
    second_argument: &Expression,
    third_argument: &Expression,
) -> Result<Expression, ApiError>

Carlson's symmetric elliptic integral RF(x,y,z)R_F(x,y,z).

carlson_rj#

api::Session method

pub fn carlson_rj(
    &self,
    first_argument: &Expression,
    second_argument: &Expression,
    third_argument: &Expression,
    fourth_argument: &Expression,
) -> Result<Expression, ApiError>

Carlson's symmetric elliptic integral RJ(x,y,z,p)R_J(x,y,z,p).

dirac_delta#

api::Session method

pub fn dirac_delta(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

Provides the dirac_delta operation on this native type.

elliptic_e#

api::Session method

pub fn elliptic_e(
    &self,
    parameter: &Expression,
) -> Result<Expression, ApiError>

The complete second-kind elliptic integral E(m)E(m), with parameter m=k2m=k^2.

elliptic_e_incomplete#

api::Session method

pub fn elliptic_e_incomplete(
    &self,
    amplitude: &Expression,
    parameter: &Expression,
) -> Result<Expression, ApiError>

The incomplete second-kind elliptic integral E(ϕ∣m)E(\phi\mid m), with parameter m=k2m=k^2.

elliptic_f#

api::Session method

pub fn elliptic_f(
    &self,
    amplitude: &Expression,
    parameter: &Expression,
) -> Result<Expression, ApiError>

The incomplete first-kind elliptic integral F(ϕ∣m)F(\phi\mid m), with parameter m=k2m=k^2.

elliptic_k#

api::Session method

pub fn elliptic_k(
    &self,
    parameter: &Expression,
) -> Result<Expression, ApiError>

The complete first-kind elliptic integral K(m)K(m), with parameter m=k2m=k^2.

elliptic_pi#

api::Session method

pub fn elliptic_pi(
    &self,
    characteristic: &Expression,
    parameter: &Expression,
) -> Result<Expression, ApiError>

The complete third-kind elliptic integral Π(n∣m)\Pi(n\mid m), with parameter m=k2m=k^2.

elliptic_pi_incomplete#

api::Session method

pub fn elliptic_pi_incomplete(
    &self,
    characteristic: &Expression,
    amplitude: &Expression,
    parameter: &Expression,
) -> Result<Expression, ApiError>

The incomplete third-kind elliptic integral Π(n;ϕ∣m)\Pi(n;\phi\mid m), with parameter m=k2m=k^2.

heaviside_step#

api::Session method

pub fn heaviside_step(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

Provides the heaviside_step operation on this native type.

jacobi_amplitude#

api::Session method

pub fn jacobi_amplitude(
    &self,
    argument: &Expression,
    parameter: &Expression,
) -> Result<Expression, ApiError>

The pinned Jacobi amplitude am⁡(u∣m)\operatorname{am}(u\mid m), with parameter m=k2m=k^2.

jacobi_cn#

api::Session method

pub fn jacobi_cn(
    &self,
    argument: &Expression,
    parameter: &Expression,
) -> Result<Expression, ApiError>

Jacobi's elliptic function cn⁡(u∣m)\operatorname{cn}(u\mid m), with parameter m=k2m=k^2.

jacobi_dn#

api::Session method

pub fn jacobi_dn(
    &self,
    argument: &Expression,
    parameter: &Expression,
) -> Result<Expression, ApiError>

Jacobi's elliptic function dn⁡(u∣m)\operatorname{dn}(u\mid m), with parameter m=k2m=k^2.

jacobi_sn#

api::Session method

pub fn jacobi_sn(
    &self,
    argument: &Expression,
    parameter: &Expression,
) -> Result<Expression, ApiError>

Jacobi's elliptic function sn⁡(u∣m)\operatorname{sn}(u\mid m), with parameter m=k2m=k^2.

jacobi_theta_1#

api::Session method

pub fn jacobi_theta_1(
    &self,
    argument: &Expression,
    half_period_ratio: &Expression,
) -> Result<Expression, ApiError>

Jacobi's first theta function θ1(z∣τ)\theta_1(z\mid\tau), with half-period ratio τ\tau.

jacobi_theta_2#

api::Session method

pub fn jacobi_theta_2(
    &self,
    argument: &Expression,
    half_period_ratio: &Expression,
) -> Result<Expression, ApiError>

Jacobi's second theta function θ2(z∣τ)\theta_2(z\mid\tau), with half-period ratio τ\tau.

jacobi_theta_3#

api::Session method

pub fn jacobi_theta_3(
    &self,
    argument: &Expression,
    half_period_ratio: &Expression,
) -> Result<Expression, ApiError>

Jacobi's third theta function θ3(z∣τ)\theta_3(z\mid\tau), with half-period ratio τ\tau.

jacobi_theta_4#

api::Session method

pub fn jacobi_theta_4(
    &self,
    argument: &Expression,
    half_period_ratio: &Expression,
) -> Result<Expression, ApiError>

Jacobi's fourth theta function θ4(z∣τ)\theta_4(z\mid\tau), with half-period ratio τ\tau.

lambert_w#

api::Session method

pub fn lambert_w(
    &self,
    argument: &Expression,
) -> Result<Expression, ApiError>

Provides the lambert_w operation on this native type.

OrthogonalPolynomialBasis#

api re_export

pub use options::OrthogonalPolynomialBasis;

A requested classical orthogonal polynomial basis and its parameters.

Calling forms

Type: api::options::OrthogonalPolynomialBasis

pub struct OrthogonalPolynomialBasis

OrthogonalPolynomialBasis.family#

api::options::OrthogonalPolynomialBasis field

pub family:

The requested family.

OrthogonalPolynomialBasis.new#

api::options::OrthogonalPolynomialBasis method

pub fn new(
    family: OrthogonalPolynomialFamily,
    parameters: Vec<Expression>,
) -> Self

Names one basis and its parameters in canonical call order.

OrthogonalPolynomialBasis.parameters#

api::options::OrthogonalPolynomialBasis field

pub parameters:

The family parameters, in canonical call order.

OrthogonalPolynomialBasis.resolve#

api::options::OrthogonalPolynomialBasis method

pub fn resolve(&self, session: &Session) -> Result<core_basis, ApiError>

Resolves this requested basis against a session that owns its parameters.

OrthogonalPolynomialFamily#

api re_export

pub use options::OrthogonalPolynomialFamily;

A classical orthogonal polynomial family named at the API boundary.

Calling forms

Type: api::options::OrthogonalPolynomialFamily

pub enum OrthogonalPolynomialFamily

OrthogonalPolynomialFamily.ChebyshevFirstKind#

api::options::OrthogonalPolynomialFamily variant

ChebyshevFirstKind,

The Chebyshev family of the first kind.

OrthogonalPolynomialFamily.ChebyshevSecondKind#

api::options::OrthogonalPolynomialFamily variant

ChebyshevSecondKind,

The Chebyshev family of the second kind.

OrthogonalPolynomialFamily.Gegenbauer#

api::options::OrthogonalPolynomialFamily variant

Gegenbauer,

The Gegenbauer family, carrying one parameter.

OrthogonalPolynomialFamily.GeneralizedLaguerre#

api::options::OrthogonalPolynomialFamily variant

GeneralizedLaguerre,

The generalized Laguerre family, carrying one parameter.

OrthogonalPolynomialFamily.Hermite#

api::options::OrthogonalPolynomialFamily variant

Hermite,

The physicists' Hermite family.

OrthogonalPolynomialFamily.Jacobi#

api::options::OrthogonalPolynomialFamily variant

Jacobi,

The Jacobi family, carrying two parameters.

OrthogonalPolynomialFamily.Legendre#

api::options::OrthogonalPolynomialFamily variant

Legendre,

The Legendre family.

OrthogonalPolynomialFamily.from_name#

api::options::OrthogonalPolynomialFamily method

pub fn from_name(name: &str) -> Result<Self, ApiError>

Resolves the stable binding spelling of an orthogonal polynomial family.

OrthogonalPolynomialFamily.into_core#

api::options::OrthogonalPolynomialFamily method

pub fn into_core(self) -> core_family

Converts this binding-neutral value to the engine representation.

OrthogonalPolynomialFamily.name#

api::options::OrthogonalPolynomialFamily method

pub fn name(self) -> &'static str

Returns the stable binding spelling of this orthogonal polynomial family.

OrthogonalPolynomialFamily.parameter_count#

api::options::OrthogonalPolynomialFamily method

pub fn parameter_count(self) -> usize

The number of family parameters this family carries.