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#
Default context
gamma(x: Any) -> ExpressionThe gamma function , the analytic continuation of (x-1)!.
log_gamma#
Default context
log_gamma(x: Any) -> ExpressionThe principal-branch log-gamma function (not log(gamma(x)) off the real axis).
digamma#
Default context
digamma(x: Any) -> ExpressionThe digamma function .
polygamma#
Default context
polygamma(order: Any, x: Any) -> ExpressionThe polygamma function , the order-th derivative of digamma;
polygamma(0, x) reduces to digamma(x).
beta#
Default context
beta(x: Any, y: Any) -> ExpressionThe beta function .
zeta#
Default context
zeta(s: Any) -> ExpressionThe Riemann zeta function . Even positive integers fold to
the 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 and .
hurwitz_zeta#
Default context
hurwitz_zeta(s: Any, a: Any) -> ExpressionThe Hurwitz zeta function , the numeric primitive of
the family. hurwitz_zeta(s, 1) folds to zeta(s); hurwitz_zeta(s, 1/2) to
; 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#
Default context
polylogarithm(order: Any, argument: Any) -> ExpressionCalling forms
Explicit context: Context.polylogarithm
polylogarithm(order: Any, argument: Any) -> ExpressionThe principal-branch polylogarithm . 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 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#
Default context
lerch_phi(argument: Any, order: Any, shift: Any) -> ExpressionCalling forms
Explicit context: Context.lerch_phi
lerch_phi(
argument: ExpressionLike,
order: ExpressionLike,
shift: ExpressionLike,
) -> ExpressionThe principal Lerch transcendent , 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 and 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#
Default context
error_function(x: Any) -> ExpressionThe error function .
error_function(0) = 0 and the values at are .
error_function_complementary#
Default context
error_function_complementary(x: Any) -> ExpressionCalling forms
Explicit context: Context.error_function_complementary
error_function_complementary(x: Any) -> ExpressionThe complementary error function .
imaginary_error_function#
Default context
imaginary_error_function(x: Any) -> ExpressionCalling forms
Explicit context: Context.imaginary_error_function
imaginary_error_function(x: Any) -> ExpressionThe imaginary error function , with derivative . It is real on the real line and grows without bound towards .
fresnel_sine_integral#
Default context
fresnel_sine_integral(x: Any) -> ExpressionCalling forms
Explicit context: Context.fresnel_sine_integral
fresnel_sine_integral(x: Any) -> ExpressionThe Fresnel sine integral in the normalization of DLMF 7.2(iv), so and .
fresnel_cosine_integral#
Default context
fresnel_cosine_integral(x: Any) -> ExpressionCalling forms
Explicit context: Context.fresnel_cosine_integral
fresnel_cosine_integral(x: Any) -> ExpressionThe Fresnel cosine integral , with and .
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#
Default context
exponential_integral(x: Any) -> ExpressionCalling forms
Explicit context: Context.exponential_integral
exponential_integral(x: Any) -> ExpressionThe exponential integral , with .
sine_integral#
Default context
sine_integral(x: Any) -> ExpressionThe sine integral . sine_integral(0) = 0 and
sine_integral(infinity) = pi/2.
cosine_integral#
Default context
cosine_integral(x: Any) -> ExpressionThe cosine integral , with .
logarithmic_integral#
Default context
logarithmic_integral(x: Any) -> ExpressionCalling forms
Explicit context: Context.logarithmic_integral
logarithmic_integral(x: Any) -> ExpressionThe logarithmic integral , with .
Generalized hypergeometric family#
Symi implements the ordinary , 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 , and strictly inside the unit disk with a margin for . Beyond that disk the Gauss function is continued through three principal-branch transformations — Pfaff's (DLMF 15.8.1), the expansion in (DLMF 15.8.4), and the expansion in (DLMF 15.8.2) — and the confluent function 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 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 to , 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 with 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 — to the exponential, a zero argument to one, safe parameter cancellation, terminating expansion within a size budget — plus Gauss's summation at (DLMF 15.4.20) when is proved; with the condition unproved the call stays symbolic, because the series there genuinely diverges when it fails.
hypergeometric_pfq#
Default context
hypergeometric_pfq(
upper_parameters: Any,
lower_parameters: Any,
argument: Any,
) -> ExpressionCalling forms
Explicit context: Context.hypergeometric_pfq
hypergeometric_pfq(
upper_parameters: Any,
lower_parameters: Any,
argument: Any,
) -> ExpressionThe generalized hypergeometric function . The two parameter groups are ordered sequences: order and repetition are significant, so a set or frozenset is rejected.
hypergeometric_0f1#
Default context
hypergeometric_0f1(lower_parameter: Any, argument: Any) -> ExpressionCalling forms
Explicit context: Context.hypergeometric_0f1
hypergeometric_0f1(lower_parameter: Any, argument: Any) -> ExpressionThe confluent limit , lowered to hypergeometric_pfq.
hypergeometric_1f1#
Default context
hypergeometric_1f1(
upper_parameter: Any,
lower_parameter: Any,
argument: Any,
) -> ExpressionCalling forms
Explicit context: Context.hypergeometric_1f1
hypergeometric_1f1(
upper_parameter: Any,
lower_parameter: Any,
argument: Any,
) -> ExpressionKummer's confluent hypergeometric function .
hypergeometric_2f1#
Default context
hypergeometric_2f1(
first_upper_parameter: Any,
second_upper_parameter: Any,
lower_parameter: Any,
argument: Any,
) -> ExpressionCalling forms
Explicit context: Context.hypergeometric_2f1
hypergeometric_2f1(
first_upper_parameter: Any,
second_upper_parameter: Any,
lower_parameter: Any,
argument: Any,
) -> ExpressionThe Gauss hypergeometric function .
Meijer G-function#
meijer_g#
Default context
meijer_g(
upper_numerator_parameters: Any,
upper_denominator_parameters: Any,
lower_numerator_parameters: Any,
lower_denominator_parameters: Any,
argument: Any,
) -> ExpressionCalling forms
Explicit context: Context.meijer_g
meijer_g(
upper_numerator_parameters: Any,
upper_denominator_parameters: Any,
lower_numerator_parameters: Any,
lower_denominator_parameters: Any,
argument: Any,
) -> ExpressionThe Meijer G-function 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 terms. It applies when , or with the argument strictly inside the unit disk, and when no two of the first 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_hypergeometricreduces an eligiblemeijer_gcall to its finite sum, and rewriteserror_functioninto its DLMF 7.11.1 confluent form;meijer_grewrites a 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#
Not exposed by the Python bindings. Available as api::Session::bessel_j in Rust.
The principal Bessel function .
bessel_y#
Not exposed by the Python bindings. Available as api::Session::bessel_y in Rust.
The principal Bessel function .
bessel_i#
Not exposed by the Python bindings. Available as api::Session::bessel_i in Rust.
The principal modified Bessel function .
bessel_k#
Not exposed by the Python bindings. Available as api::Session::bessel_k in Rust.
The principal modified Bessel function .
hankel_first_kind#
Not exposed by the Python bindings. Available as api::Session::hankel_first_kind in Rust.
The principal Hankel function .
hankel_second_kind#
Not exposed by the Python bindings. Available as api::Session::hankel_second_kind in Rust.
The principal Hankel function .
spherical_bessel_j#
Not exposed by the Python bindings. Available as api::Session::spherical_bessel_j in Rust.
The spherical Bessel function , for .
spherical_bessel_y#
Not exposed by the Python bindings. Available as api::Session::spherical_bessel_y in Rust.
The spherical Bessel function , for .
spherical_hankel_first_kind#
Not exposed by the Python bindings. Available as api::Session::spherical_hankel_first_kind in Rust.
The spherical Hankel function , for .
spherical_hankel_second_kind#
Not exposed by the Python bindings. Available as api::Session::spherical_hankel_second_kind in Rust.
The spherical Hankel function , for .
airy_ai#
Not exposed by the Python bindings. Available as api::Session::airy_ai in Rust.
The Airy function .
airy_bi#
Not exposed by the Python bindings. Available as api::Session::airy_bi in Rust.
The Airy function .
airy_ai_prime#
Not exposed by the Python bindings. Available as api::Session::airy_ai_prime in Rust.
The derivative .
airy_bi_prime#
Not exposed by the Python bindings. Available as api::Session::airy_bi_prime in Rust.
The derivative .
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 , , and are conditions of the
weighted-inner-product theorems, not conditions for the polynomial to have a value. hermite_polynomial
is the physicists' .
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#
Default context
jacobi_polynomial(
degree: ExpressionLike,
first_parameter: ExpressionLike,
second_parameter: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionCalling forms
Explicit context: Context.jacobi_polynomial
jacobi_polynomial(
degree: ExpressionLike,
first_parameter: ExpressionLike,
second_parameter: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionThe Jacobi polynomial .
gegenbauer_polynomial#
Default context
gegenbauer_polynomial(
degree: ExpressionLike,
parameter: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionCalling forms
Explicit context: Context.gegenbauer_polynomial
gegenbauer_polynomial(
degree: ExpressionLike,
parameter: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionThe Gegenbauer polynomial .
chebyshev_polynomial_first_kind#
Default context
chebyshev_polynomial_first_kind(
degree: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionCalling forms
Explicit context: Context.chebyshev_polynomial_first_kind
chebyshev_polynomial_first_kind(
degree: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionThe Chebyshev polynomial of the first kind .
chebyshev_polynomial_second_kind#
Default context
chebyshev_polynomial_second_kind(
degree: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionCalling forms
Explicit context: Context.chebyshev_polynomial_second_kind
chebyshev_polynomial_second_kind(
degree: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionThe Chebyshev polynomial of the second kind .
legendre_polynomial#
Default context
legendre_polynomial(
degree: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionCalling forms
Explicit context: Context.legendre_polynomial
legendre_polynomial(
degree: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionThe Legendre polynomial .
generalized_laguerre_polynomial#
Default context
generalized_laguerre_polynomial(
degree: ExpressionLike,
parameter: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionCalling forms
Explicit context: Context.generalized_laguerre_polynomial
generalized_laguerre_polynomial(
degree: ExpressionLike,
parameter: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionThe generalized Laguerre polynomial .
hermite_polynomial#
Default context
hermite_polynomial(
degree: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionCalling forms
Explicit context: Context.hermite_polynomial
hermite_polynomial(
degree: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionThe physicists' Hermite polynomial .
ultraspherical_polynomial#
Default context
ultraspherical_polynomial(
degree: ExpressionLike,
parameter: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionCalling forms
Explicit context: Context.ultraspherical_polynomial
ultraspherical_polynomial(
degree: ExpressionLike,
parameter: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionThe ultraspherical polynomial, lowered to its canonical Gegenbauer head.
laguerre_polynomial#
Default context
laguerre_polynomial(
degree: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionCalling forms
Explicit context: Context.laguerre_polynomial
laguerre_polynomial(
degree: ExpressionLike,
argument: ExpressionLike,
) -> ExpressionThe Laguerre polynomial, lowered to its canonical generalized Laguerre head.
Example#
Special functions reduce at recognised arguments.
import symi
print(symi.gamma(symi.rational(1, 2)))
print(symi.zeta(2))
print(symi.beta(2, 3))
print(symi.digamma(1))convert_polynomial_basis#
Not exposed by the Python bindings. Available as api::Expression::convert_polynomial_basis in Rust.
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#
Not exposed by the Python bindings. Available as api::Expression::orthogonal_polynomial_coefficient in Rust.
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#
Not exposed by the Python bindings. Available as api::Expression::expand_orthogonal_polynomial in Rust.
The inverse direction: expand every classical orthogonal polynomial call in the expression into an ordinary polynomial in its variable.
Additional API#
carlson_rc#
Default context
carlson_rc(
first_argument: ExpressionLike,
second_argument: ExpressionLike,
) -> ExpressionCarlson's degenerate symmetric elliptic integral .
Calling forms
Explicit context: Context.carlson_rc
carlson_rc(
first_argument: ExpressionLike,
second_argument: ExpressionLike,
) -> Expressioncarlson_rd#
Default context
carlson_rd(
first_argument: ExpressionLike,
second_argument: ExpressionLike,
third_argument: ExpressionLike,
) -> ExpressionCarlson's symmetric elliptic integral .
Calling forms
Explicit context: Context.carlson_rd
carlson_rd(
first_argument: ExpressionLike,
second_argument: ExpressionLike,
third_argument: ExpressionLike,
) -> Expressioncarlson_rf#
Default context
carlson_rf(
first_argument: ExpressionLike,
second_argument: ExpressionLike,
third_argument: ExpressionLike,
) -> ExpressionCarlson's symmetric elliptic integral .
Calling forms
Explicit context: Context.carlson_rf
carlson_rf(
first_argument: ExpressionLike,
second_argument: ExpressionLike,
third_argument: ExpressionLike,
) -> Expressioncarlson_rj#
Default context
carlson_rj(
first_argument: ExpressionLike,
second_argument: ExpressionLike,
third_argument: ExpressionLike,
fourth_argument: ExpressionLike,
) -> ExpressionCarlson's symmetric elliptic integral .
Calling forms
Explicit context: Context.carlson_rj
carlson_rj(
first_argument: ExpressionLike,
second_argument: ExpressionLike,
third_argument: ExpressionLike,
fourth_argument: ExpressionLike,
) -> Expressionelliptic_e#
Default context
elliptic_e(parameter: ExpressionLike) -> ExpressionThe complete second-kind elliptic integral , with parameter .
Calling forms
Explicit context: Context.elliptic_e
elliptic_e(parameter: ExpressionLike) -> Expressionelliptic_e_incomplete#
Default context
elliptic_e_incomplete(
amplitude: ExpressionLike,
parameter: ExpressionLike,
) -> ExpressionThe incomplete second-kind elliptic integral , with parameter .
Calling forms
Explicit context: Context.elliptic_e_incomplete
elliptic_e_incomplete(
amplitude: ExpressionLike,
parameter: ExpressionLike,
) -> Expressionelliptic_f#
Default context
elliptic_f(
amplitude: ExpressionLike,
parameter: ExpressionLike,
) -> ExpressionThe incomplete first-kind elliptic integral , with parameter .
Calling forms
Explicit context: Context.elliptic_f
elliptic_f(
amplitude: ExpressionLike,
parameter: ExpressionLike,
) -> Expressionelliptic_k#
Default context
elliptic_k(parameter: ExpressionLike) -> ExpressionThe complete first-kind elliptic integral , with parameter .
Calling forms
Explicit context: Context.elliptic_k
elliptic_k(parameter: ExpressionLike) -> Expressionelliptic_pi#
Default context
elliptic_pi(
characteristic: ExpressionLike,
parameter: ExpressionLike,
) -> ExpressionThe complete third-kind elliptic integral , with parameter .
Calling forms
Explicit context: Context.elliptic_pi
elliptic_pi(
characteristic: ExpressionLike,
parameter: ExpressionLike,
) -> Expressionelliptic_pi_incomplete#
Default context
elliptic_pi_incomplete(
characteristic: ExpressionLike,
amplitude: ExpressionLike,
parameter: ExpressionLike,
) -> ExpressionThe incomplete third-kind elliptic integral , with parameter .
Calling forms
Explicit context: Context.elliptic_pi_incomplete
elliptic_pi_incomplete(
characteristic: ExpressionLike,
amplitude: ExpressionLike,
parameter: ExpressionLike,
) -> Expressionjacobi_amplitude#
Default context
jacobi_amplitude(
argument: ExpressionLike,
parameter: ExpressionLike,
) -> ExpressionThe pinned Jacobi amplitude , with parameter .
Calling forms
Explicit context: Context.jacobi_amplitude
jacobi_amplitude(
argument: ExpressionLike,
parameter: ExpressionLike,
) -> Expressionjacobi_cn#
Default context
jacobi_cn(
argument: ExpressionLike,
parameter: ExpressionLike,
) -> ExpressionJacobi's elliptic function , with parameter .
Calling forms
Explicit context: Context.jacobi_cn
jacobi_cn(
argument: ExpressionLike,
parameter: ExpressionLike,
) -> Expressionjacobi_dn#
Default context
jacobi_dn(
argument: ExpressionLike,
parameter: ExpressionLike,
) -> ExpressionJacobi's elliptic function , with parameter .
Calling forms
Explicit context: Context.jacobi_dn
jacobi_dn(
argument: ExpressionLike,
parameter: ExpressionLike,
) -> Expressionjacobi_sn#
Default context
jacobi_sn(
argument: ExpressionLike,
parameter: ExpressionLike,
) -> ExpressionJacobi's elliptic function , with parameter .
Calling forms
Explicit context: Context.jacobi_sn
jacobi_sn(
argument: ExpressionLike,
parameter: ExpressionLike,
) -> Expressionjacobi_theta_1#
Default context
jacobi_theta_1(
argument: ExpressionLike,
tau: ExpressionLike,
) -> ExpressionJacobi's first theta function , with half-period ratio .
Calling forms
Explicit context: Context.jacobi_theta_1
jacobi_theta_1(
argument: ExpressionLike,
tau: ExpressionLike,
) -> Expressionjacobi_theta_2#
Default context
jacobi_theta_2(
argument: ExpressionLike,
tau: ExpressionLike,
) -> ExpressionJacobi's second theta function , with half-period ratio .
Calling forms
Explicit context: Context.jacobi_theta_2
jacobi_theta_2(
argument: ExpressionLike,
tau: ExpressionLike,
) -> Expressionjacobi_theta_3#
Default context
jacobi_theta_3(
argument: ExpressionLike,
tau: ExpressionLike,
) -> ExpressionJacobi's third theta function , with half-period ratio .
Calling forms
Explicit context: Context.jacobi_theta_3
jacobi_theta_3(
argument: ExpressionLike,
tau: ExpressionLike,
) -> Expressionjacobi_theta_4#
Default context
jacobi_theta_4(
argument: ExpressionLike,
tau: ExpressionLike,
) -> ExpressionJacobi's fourth theta function , with half-period ratio .