WSNumericalSpecialFunctions R

jwsnsf.spad line 1 [edit on github]

Julia Wolfram Symbolic numerical special functions using the MathLink Julia package.

airyAi: R -> R

airyAi(z) is the Airy function Ai(z).

airyAiPrime: R -> R

airyAiPrime(z) is the derivative of the Airy function Ai(z).

airyAiZero: (R, R) -> R

airyAiZero(n,x) is n-th zero function of the Airy function Ai(z) smaller than x.

airyAiZero: R -> R

airyAiZero(n) is n-th zero function of the Airy function Ai(z).

airyBi: R -> R

airyBi(z) is the Airy function Bi(z).

airyBiPrime: R -> R

airyBiPrime(z) is the derivative of the Airy function Bi(z).

airyBiZero: (R, R) -> R

airyBiZero(n,x) is n-th zero function of the Airy function Bi(z) smaller than x.

airyBiZero: R -> R

airyBiZero(n) is n-th zero function of the Airy function Bi(z).

angerJ: (R, R) -> R

angerJ(v, z) is the Anger J function.

barnesG: R -> R

barnesG(z) computes the Barnes G-function of z.

besselI: (R, R) -> R

besselI(v, z) is the modified Bessel function of the first kind.

besselJ: (R, R) -> R

besselJ(v, z) is the Bessel function of the first kind.

besselJZero: (R, R) -> R

besselJZero(n,x) returns the n-th zero of the Bessel J n-th function.

besselK: (R, R) -> R

besselK(v, z) is the modified Bessel function of the second kind.

besselY: (R, R) -> R

besselY(v, z) is the Bessel function of the second kind.

besselYZero: (R, R) -> R

besselYZero(n,x) returns the n-th zero of the Bessel Y n-th function.

Beta: (R, R) -> R

Beta(x, y) is Gamma(x) * Gamma(y)/Gamma(x+y).

Beta: (R, R, R) -> R

Beta(z, a, b) is the incomplete Beta function.

BetaRegularized: (R, R, R) -> R

BetaRegularized(z,a,b) computes the regularized incomplete beta function.

charlierC: (R, R, R) -> R

charlierC(n, a, z) is the Charlier polynomial

chebyshevT: (R, R) -> R

chebyshevT(n, z) evaluates the chebyshev polynomial of the first kind at z.

chebyshevU: (R, R) -> R

chebyshevU(n, expr) evaluates the chebyshev polynomial of the second kind at z.

coulombF: (R, R, R) -> R

coulombF(l,eta,ro) is the regular Coulomb wave function.

coulombG: (R, R, R) -> R

coulombG(l,eta,ro) is the irregular Coulomb wave function.

coulombH1: (R, R, R) -> R

coulombH1(l,eta,ro) is the incoming irregular Coulomb wave function H^(+).

coulombH2: (R, R, R) -> R

coulombH2(l,eta,ro) is the incoming irregular Coulomb wave function H^(-).

dawson: R -> R

dawson(x) computes the Dawson integral of x.

dedekindEta: R -> R

dedekindEta(tau) computes the Dedekind modular elliptic eta.

digamma: (R, R) -> R

digamma(n,z) the n-th derivative of the digamma function

digamma: R -> R

digamma(z) is the logarithmic derivative of Gamma(z) (often written psi(z) in the literature).

dirichletEta: R -> R

dirichletEta(z) computes the Dirichlet eta of z.

dirichletL: (R, R, R) -> R

dirichletL(k,j,s) returns Dirichlet L-function of s, modulus k, index j.

EiEn: (WSInteger, R) -> R

EiEn(n,z) returns the exponential integral En of z.

ellipticE: (R, R) -> R

ellipticE(z, m) is the incomplete elliptic integral of the second kind: ellipticE(z, m) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2), t = 0..z).

ellipticE: R -> R

ellipticE(m) is the complete elliptic integral of the second kind: ellipticE(m) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2), t = 0..1).

ellipticF: (R, R) -> R

ellipticF(z, m) is the incomplete elliptic integral of the first kind : ellipticF(z, m) = integrate(1/sqrt((1-t^2)*(1-m*t^2)), t = 0..z).

ellipticK: R -> R

ellipticK(m) is the complete elliptic integral of the first kind: ellipticK(m) = integrate(1/sqrt((1-t^2)*(1-m*t^2)), t = 0..1).

ellipticPi: (R, R) -> R

ellipticPi(n,m) computes the complete elliptic integral of the third kind.

ellipticPi: (R, R, R) -> R

ellipticPi(z, n, m) is the incomplete elliptic integral of the third kind: ellipticPi(z, n, m) = integrate(1/((1-n*t^2)*sqrt((1-t^2)*(1-m*t^2))), t = 0..z).

ellipticTheta: (R, R, R) -> R

ellipticTheta(a, u, q) computes the theta function, a ranges from 1 to 4.

ellipticThetaPrime: (R, R, R) -> R

ellipticThetaPrime(a, u, q) computes the derivative of the theta function, a ranges from 1 to 4.

fibonacci: (WSInteger, R) -> R

fibonacci(n, z) evaluates the Fibonacci polynomial at z.

Gamma: (R, R) -> R

Gamma(a, z) is the incomplete Gamma function.

Gamma: (R, R, R) -> R

Gamma(a,z1,z2) computes the generalized incomplete gamma function.

Gamma: R -> R

Gamma(z) is the Euler Gamma function.

GammaRegularized: (R, R) -> R

GammaRegularized(a,z) computes the regularized incomplete gamma function.

gegenbauerC: (WSInteger, R) -> R

gegenbauerC(n,z) evaluates the renormalized form of the Gegenbauer polynomial at z.

gegenbauerC: (WSInteger, R, R) -> R

gegenbauerC(n,lambda,z) evaluates the Gegenbauer polynomial at z.

gudermannian: R -> R

gudermannian(z) computes the gudermannian of z.

hankelH1: (R, R) -> R

hankelH1(v, z) is first Hankel function (Bessel function of the third kind).

hankelH2: (R, R) -> R

hankelH2(v, z) is the second Hankel function (Bessel function of the third kind).

haversine: R -> R

haversine(z) computes the haversine of z.

hermiteH: (R, R) -> R

hermiteH(n, z) evaluates the Hermite polynomial at z.

hurwitzLerchPhi: (R, R, R) -> R

hurwitzLerchPhi(z,s,a) computes the Hurwitz–Lerch transcendent phi function.

hurwitzZeta: (R, R) -> R

hurwitzZeta(s,a) computes the Hurwitz zeta.

hyperFactorial: R -> R

hyperFactorial(n) computes the hyperfactorial of n.

hypergeometric0F1: (R, R) -> R

hypergeometric0F1(a,z) is the hypergeometric 0F1.

hypergeometric0F1Regularized: (R, R) -> R

hypergeometric0F1Regularized(a,z) is the regularized hypergeometric 0F1.

hypergeometric1F1: (R, R, R) -> R

hypergeometric1F1(a,b,z) is the Kummer confluent hypergeometric function 1F1.

hypergeometric1F1Regularized: (R, R, R) -> R

hypergeometric1F1Regularized(a,b,z) is the regularized confluent hypergeometric function 1F1.

hypergeometricU: (R, R, R) -> R

hypergeometricU(a,b,z) is the confluent hypergeometric function U.

inverseBetaRegularized: (R, R, R) -> R

inverseBetaRegularized(s,a,b) computes the beta inverse.

inverseErf: R -> R

inverseErf(z) computes the inverse error function of z.

inverseErfc: R -> R

inverseErfc(z) computes the inverse complementary error function of z.

inverseGammaRegularized: (R, R) -> R

inverseGammaRegularized(a,s) computes the gamma inverse.

inverseGudermannian: R -> R

inverseGudermannian(z) computes the inverse gudermannian.

inverseHaversine: R -> R

inverseHaversine(z) computes the inverse haversine.

inverseJacobiCn: (R, R) -> R

inverseJacobiCn(nu, m) computes the inverse JacobiCN elliptic function.

inverseJacobiSn: (R, R) -> R

inverseJacobiSn(nu, m) computes the inverse JacobiSN elliptic function.

jacobiAmplitude: (R, R) -> R

jacobiAmplitude(u,m) computes the amplitude function am.

jacobiCn: (R, R) -> R

jacobiCn(z, m) is the Jacobi elliptic cn function, defined by jacobiCn(z, m)^2 + jacobiSn(z, m)^2 = 1 and jacobiCn(0, m) = 1.

jacobiDn: (R, R) -> R

jacobiDn(z, m) is the Jacobi elliptic dn function, defined by jacobiDn(z, m)^2 + m*jacobiSn(z, m)^2 = 1 and jacobiDn(0, m) = 1.

jacobiP: (R, R, R, R) -> R

jacobiP(n, a, b, z) evaluates the Jacobi polynomial at z.

jacobiSn: (R, R) -> R

jacobiSn(z, m) is the Jacobi elliptic sn function, defined by the formula jacobiSn(ellipticF(z, m), m) = z.

jacobiTheta: (R, R) -> R

jacobiTheta(z, m) is the Jacobi Theta function in Jacobi notation.

jacobiZeta: (R, R) -> R

jacobiZeta(z, m) is the Jacobi elliptic zeta function, defined by D(jacobiZeta(z, m), z) = jacobiDn(z, m)^2 - ellipticE(m)/ellipticK(m) and jacobiZeta(0, m) = 0.

kelvinBei: (R, R) -> R

kelvinBei(v, z) is the Kelvin bei function defined by equality kelvinBei(v, z) = imag(besselJ(v, exp(3*Rpi*Ri/4)*z)) for z and v real.

kelvinBer: (R, R) -> R

kelvinBer(v, z) is the Kelvin ber function defined by equality kelvinBer(v, z) = real(besselJ(v, exp(3*Rpi*Ri/4)*z)) for z and v real.

kelvinKei: (R, R) -> R

kelvinKei(v, z) is the Kelvin kei function defined by equality kelvinKei(v, z) = imag(exp(-v*Rpi*Ri/2)*besselK(v, exp(Rpi*Ri/4)*z)) for z and v real.

kelvinKer: (R, R) -> R

kelvinKer(v, z) is the Kelvin kei function defined by equality kelvinKer(v, z) = real(exp(-v*Rpi*Ri/2)*besselK(v, exp(Rpi*Ri/4)*z)) for z and v real.

kleinInvariantJ: R -> R

kleinInvariantJ(tau) computes the Klein's absolute invariant.

kummerM: (R, R, R) -> R

kummerM(mu, nu, z) is the Kummer M function.

kummerU: (R, R, R) -> R

kummerU(mu, nu, z) is the Kummer U function.

laguerreL: (R, R) -> R

laguerreL(n, z) evaluates the Laguerre polynomial at z.

laguerreL: (R, R, R) -> R

laguerreL(n, a, z) evaluates he genralized Laguerre polynomial a z.

lambertW: (WSInteger, R) -> R

lambertW(k,z) returns the k-th solution to LambertW function.

lambertW: R -> R

lambertW(z) = w is the principial branch of the solution to the equation we^w = z.

legendreP: (R, R) -> R

legendreP(n, z) evaluates the legendre polynomial of the first kind at z.

legendreP: (R, R, R) -> R

legendreP(nu, mu, z) is the Legendre P function.

legendreQ: (R, R) -> R

legendreQ(n, z) returns the Legendre function of the second kind.

legendreQ: (R, R, R) -> R

legendreQ(nu, mu, z) is the Legendre Q function.

lerchPhi: (R, R, R) -> R

lerchPhi(z, s, a) is the Lerch Phi function.

logBarnesG: R -> R

logBarnesG(z) is the logarithm of Barnes-G.

logGamma: R -> R

logGamma(z) returns the log-gamma of z.

lommelS1: (R, R, R) -> R

lommelS1(mu, nu, z) is the Lommel s function.

lommelS2: (R, R, R) -> R

lommelS2(mu, nu, z) is the Lommel S function.

mathieuC: (R, R, R) -> R

mathieuC(a,q,z) is the even Mathieu function with characteristic a and parameter q.

mathieuCharacteristicA: (R, R) -> R

mathieuCharacteristicA(r,q) returns the characteristic for even Mathieu function.

mathieuCharacteristicB: (R, R) -> R

mathieuCharacteristicB(r,q) returns the characteristic for odd Mathieu function.

mathieuCharacteristicExponent: (R, R) -> R

mathieuCharacteristicExponent(a,q) returns the characterisitc exponent o he Mathieu function.

mathieuCPrime: (R, R, R) -> R

mathieuCPrime(a,q,z) derivative of the even Mathieu function.

mathieuS: (R, R, R) -> R

mathieuS(b,q,z) is the odd Mathieu function with characteristic b and parameter q.

mathieuSPrime: (R, R, R) -> R

mathieuSPrime(b,q,z) derivative of the odd Mathieu function.

meixnerM: (R, R, R, R) -> R

meixnerM(n, b, c, z) is the Meixner polynomial

modularLambda: R -> R

modularLambda() computes the lambda modular function.

parabolicCylinderD: (R, R) -> R

parabolicCylinderD(nu,z) computes the parabolic cylinder function D of z.

pochhammer: (R, R) -> R

pochhammer(a,n) returns the Pochhammer symbol.

polygamma: (R, R) -> R

polygamma(k, z) is the k-th derivative of digamma(z), (often written psi(k, z) in the literature).

polylog: (R, R) -> R

polylog(s, z) is the polylogarithm of order s at z.

polylog: (R, R, R) -> R

polylog(n,p,z) is the Nielsen generalized polylogarithm function.

QBinomial: (R, R, R) -> R

QBinomial(n,m,q) returns the q-analog of binomial coefficient.

QFactorial: (R, R) -> R

QFactorial(z,q) returns the q-analog of factorial of z.

QGamma: (R, R) -> R

QGamma(z,q) returns the q-analog of Euler gamma of z.

QPochhammer: (R, R) -> R

QPochhammer(z,q) returns the q-Pochammer symbol of z.

QPochhammer: (R, R, R) -> R

QPochhammer(z,q,n) returns the q-Pochammer symbol of z.

QPolyGamma: (R, R) -> R

QPolyGamma(z,q) returs the q-digamma of z.

QPolyGamma: (R, R, R) -> R

QPolyGamma(n,z,q) returns the n-th derivative of the q-digamma function of z.

ramanujanTau: R -> R

ramanujanTau(n) returns the Ramanujan tau of n.

ramanujanTauL: R -> R

ramanujanTauL(s) computes the Ramanujan tau Dirichlet L-function of s.

ramanujanTauTheta: R -> R

ramanujanTauTheta(z) returns the Ramanujan tau theta of z.

ramanujanTauZ: R -> R

ramanujanTauZ(t) computes the Ramanujan tau Z-function of t.

riemannSiegelTheta: R -> R

riemannSiegelTheta(t) returns the Riemann-Siegel theta function of t.

riemannSiegelZ: R -> R

riemannSiegelZ(t) computes the Riemann-Siegel Z function of t.

riemannZeta: (R, R) -> R

riemannZeta(s,a) is the generalized Riemann zeta function.

riemannZeta: R -> R

riemannZeta(z) is the Riemann Zeta function.

sphericalBesselJ: (R, R) -> R

sphericalBesselJ(n,z) returns the spherical Bessel of the first kind of z.

sphericalBesselY: (R, R) -> R

sphericalBesselY(n,z) returns the spherical Bessel of the second kind of z.

sphericalHankelH1: (R, R) -> R

sphericalHankelH1(n,z) returns the spherical Hankel of the first kind of z.

sphericalHankelH2: (R, R) -> R

sphericalHankelH2(n,z) computes the spherical Hankel of the second kind of z.

sphericalHarmonicY: (R, R, R, R) -> R

sphericalHarmonicY(l, m, theta, phi) returns the spherical harmonic Y or evaluates it.

stieltjesGamma: (WSInteger, R) -> R

stieltjesGamma(n,a) returns the generalized n-th Stieltjes constant.

stieltjesGamma: WSInteger -> R

stieltjesGamma(n) returns the n-th Stieltjes constant.

struveH: (R, R) -> R

struveH(v, z) is the Struve H function.

struveL: (R, R) -> R

struveL(v, z) is the Struve L function defined by the formula struveL(v, z) = -Ri^exp(-v*Rpi*Ri/2)*struveH(v, Ri*z).

weberE: (R, R) -> R

weberE(v, z) is the Weber E function.

weberE: (R, R, R) -> R

weberE(v, n, z) is the associated Weber E function.

weierstrassP: (R, R, R) -> R

weierstrassP(g2, g3, z) is the Weierstrass P function.

weierstrassPInverse: (R, R, R) -> R

weierstrassPInverse(g2, g3, z) is the inverse of Weierstrass P function, defined by the formula weierstrassP(g2, g3, weierstrassPInverse(g2, g3, z)) = z.

weierstrassPPrime: (R, R, R) -> R

weierstrassPPrime(g2, g3, z) is the derivative of Weierstrass P function.

weierstrassSigma: (R, R, R) -> R

weierstrassSigma(g2, g3, z) is the Weierstrass Sigma function.

weierstrassZeta: (R, R, R) -> R

weierstrassZeta(g2, g3, z) is the Weierstrass Zeta function.

whittakerM: (R, R, R) -> R

whittakerM(k, m, z) is the Whittaker M function.

whittakerW: (R, R, R) -> R

whittakerW(k, m, z) is the Whittaker W function.

zernikeR: (R, R, R) -> R

zernikeR(n, m, z) evaluates the Zernike radial polynomial at z.