Symbolic functions

This is a list of the symbolic functions available in Qmod for applying on classical parameters in expressions context.

symbolic

Modules:

Name	Description
`model_state_container`

Functions:

Name	Description
`Piecewise`
`abs`
`acos`
`acosh`
`acot`
`acoth`
`acsc`
`asec`
`asech`
`asin`
`asinh`
`atan`
`atanh`
`bell`
`bernoulli`
`besseli`
`besselj`
`besselk`
`bessely`
`beta`
`binomial`
`catalan`
`ceiling`
`cos`
`cosh`
`cot`
`coth`
`csc`
`csch`
`dirichlet_eta`
`erf`
`erfc`
`euler`
`exp`
`factorial`
`floor`
`gamma`
`ln`
`log`
`loggamma`
`logical_and`
`logical_not`
`logical_or`
`max`
`min`
`mod_inverse`
`polygamma`
`primorial`
`sec`
`sech`
`sin`
`sinh`
`sqrt`
`subfactorial`
`subscript`
`sum`
`tan`
`tanh`

Attributes:

Name	Type	Description
`Catalan`
`E`
`EulerGamma`
`GoldenRatio`
`I`
`pi`

Catalan

Catalan = SymbolicExpr('Catalan', False)

E

E = SymbolicExpr('E', False)

EulerGamma

EulerGamma = SymbolicExpr('EulerGamma', False)

GoldenRatio

GoldenRatio = SymbolicExpr('GoldenRatio', False)

I

I = SymbolicExpr('I', False)

T

T = TypeVar('T', bound=CParam)

pi

pi = SymbolicExpr('pi', False)

Piecewise

Piecewise(
    *args: tuple[SymbolicTypes, SymbolicTypes]
) -> CParamScalar

abs

abs(x: SymbolicTypes) -> CParamScalar

acos

acos(x: SymbolicTypes) -> CParamScalar

acosh

acosh(x: SymbolicTypes) -> CParamScalar

acot

acot(x: SymbolicTypes) -> CParamScalar

acoth

acoth(x: SymbolicTypes) -> CParamScalar

acsc

acsc(x: SymbolicTypes) -> CParamScalar

asec

asec(x: SymbolicTypes) -> CParamScalar

asech

asech(x: SymbolicTypes) -> CParamScalar

asin

asin(x: SymbolicTypes) -> CParamScalar

asinh

asinh(x: SymbolicTypes) -> CParamScalar

atan

atan(x: SymbolicTypes) -> CParamScalar

atanh

atanh(x: SymbolicTypes) -> CParamScalar

bell

bell(x: SymbolicTypes) -> CParamScalar

bernoulli

bernoulli(x: SymbolicTypes) -> CParamScalar

besseli

besseli(x: SymbolicTypes) -> CParamScalar

besselj

besselj(x: SymbolicTypes) -> CParamScalar

besselk

besselk(x: SymbolicTypes) -> CParamScalar

bessely

bessely(x: SymbolicTypes) -> CParamScalar

beta

beta(x: SymbolicTypes) -> CParamScalar

binomial

binomial(x: SymbolicTypes) -> CParamScalar

catalan

catalan(x: SymbolicTypes) -> CParamScalar

ceiling

ceiling(x: SymbolicTypes) -> CParamScalar

cos

cos(x: SymbolicTypes) -> CParamScalar

cosh

cosh(x: SymbolicTypes) -> CParamScalar

cot

cot(x: SymbolicTypes) -> CParamScalar

coth

coth(x: SymbolicTypes) -> CParamScalar

csc

csc(x: SymbolicTypes) -> CParamScalar

csch

csch(x: SymbolicTypes) -> CParamScalar

dirichlet_eta

dirichlet_eta(x: SymbolicTypes) -> CParamScalar

erf

erf(x: SymbolicTypes) -> CParamScalar

erfc

erfc(x: SymbolicTypes) -> CParamScalar

euler

euler(x: SymbolicTypes) -> CParamScalar

exp

exp(x: SymbolicTypes) -> CParamScalar

factorial

factorial(x: SymbolicTypes) -> CParamScalar

floor

floor(x: SymbolicTypes) -> CParamScalar

gamma

gamma(x: SymbolicTypes) -> CParamScalar

ln

ln(x: SymbolicTypes) -> CParamScalar

log

log(
    x: SymbolicTypes, base: SymbolicTypes = E
) -> CParamScalar

loggamma

loggamma(x: SymbolicTypes) -> CParamScalar

logical_and

logical_and(
    x: SymbolicTypes, y: SymbolicTypes
) -> SymbolicExpr

logical_not

logical_not(x: SymbolicTypes) -> SymbolicExpr

logical_or

logical_or(
    x: SymbolicTypes, y: SymbolicTypes
) -> SymbolicExpr

max

max(x: SymbolicTypes, y: SymbolicTypes) -> CParamScalar

min

min(x: SymbolicTypes, y: SymbolicTypes) -> CParamScalar

mod_inverse

mod_inverse(
    a: SymbolicTypes, m: SymbolicTypes
) -> CParamScalar

polygamma

polygamma(x: SymbolicTypes) -> CParamScalar

primorial

primorial(x: SymbolicTypes) -> CParamScalar

sec

sec(x: SymbolicTypes) -> CParamScalar

sech

sech(x: SymbolicTypes) -> CParamScalar

sin

sin(x: SymbolicTypes) -> CParamScalar

sinh

sinh(x: SymbolicTypes) -> CParamScalar

sqrt

sqrt(x: SymbolicTypes) -> CParamScalar

subfactorial

subfactorial(x: SymbolicTypes) -> CParamScalar

subscript

subscript(
    amplitudes: Union[
        list[float],
        list[CReal],
        list[CParamScalar],
        CArray[CReal],
    ],
    index: QNum,
) -> CParamScalar

sum

sum(arr: SymbolicTypes) -> CParamScalar

symbolic_function

symbolic_function(
    *args: Any, return_type: None = None
) -> CParamScalar

symbolic_function(*args: Any, return_type: type[T]) -> T

symbolic_function(
    *args: Any, return_type: Optional[type[T]] = None
) -> CParam

tan

tan(x: SymbolicTypes) -> CParamScalar

tanh

tanh(x: SymbolicTypes) -> CParamScalar