Next: Elliptic Functions, Previous: Polynomials, Up: Top [Contents][Index]
Next: Bessel Functions, Previous: Special Functions, Up: Special Functions [Contents][Index]
Special function notation follows:
bessel_j (index, expr) Bessel function, 1st kind bessel_y (index, expr) Bessel function, 2nd kind bessel_i (index, expr) Modified Bessel function, 1st kind bessel_k (index, expr) Modified Bessel function, 2nd kind hankel_1 (v,z) Hankel function of the 1st kind hankel_2 (v,z) Hankel function of the 2nd kind struve_h (v,z) Struve H function struve_l (v,z) Struve L function assoc_legendre_p[v,u] (z) Legendre function of degree v and order u assoc_legendre_q[v,u] (z) Legendre function, 2nd kind %f[p,q] ([], [], expr) Generalized Hypergeometric function gamma (z) Gamma function gamma_incomplete_lower (a,z) Lower incomplete gamma function gamma_incomplete (a,z) Tail of incomplete gamma function hypergeometric (l1, l2, z) Hypergeometric function slommel %m[u,k] (z) Whittaker function, 1st kind %w[u,k] (z) Whittaker function, 2nd kind erfc (z) Complement of the erf function expintegral_e (v,z) Exponential integral E expintegral_e1 (z) Exponential integral E1 expintegral_ei (z) Exponential integral Ei expintegral_li (z) Logarithmic integral Li expintegral_si (z) Exponential integral Si expintegral_ci (z) Exponential integral Ci expintegral_shi (z) Exponential integral Shi expintegral_chi (z) Exponential integral Chi kelliptic (z) Complete elliptic integral of the first kind (K) parabolic_cylinder_d (v,z) Parabolic cylinder D function
Categories: Bessel functions Airy functions Special functions
Next: Airy Functions, Previous: Introduction to Special Functions, Up: Special Functions [Contents][Index]
The Bessel function of the first kind of order v and argument z.
bessel_j
is defined as
inf ==== k - v - 2 k v + 2 k \ (- 1) 2 z > -------------------------- / k! gamma(v + k + 1) ==== k = 0
although the infinite series is not used for computations.
Categories: Bessel functions Special functions
The Bessel function of the second kind of order v and argument z.
bessel_y
is defined as
cos(%pi v) bessel_j(v, z) - bessel_j(-v, z) ------------------------------------------- sin(%pi v)
when v is not an integer. When v is an integer n, the limit as v approaches n is taken.
Categories: Bessel functions Special functions
The modified Bessel function of the first kind of order v and argument z.
bessel_i
is defined as
inf ==== - v - 2 k v + 2 k \ 2 z > ------------------- / k! gamma(v + k + 1) ==== k = 0
although the infinite series is not used for computations.
Categories: Bessel functions Special functions
The modified Bessel function of the second kind of order v and argument z.
bessel_k
is defined as
%pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z)) ------------------------------------------------- 2
when v is not an integer. If v is an integer n, then the limit as v approaches n is taken.
Categories: Bessel functions Special functions
The Hankel function of the first kind of order v and argument z
(A&S 9.1.3). hankel_1
is defined as
bessel_j(v,z) + %i * bessel_y(v,z)
Maxima evaluates hankel_1
numerically for a complex order v and
complex argument z in float precision. The numerical evaluation in
bigfloat precision is not supported.
When besselexpand
is true
, hankel_1
is expanded in terms
of elementary functions when the order v is half of an odd integer.
See besselexpand
.
Maxima knows the derivative of hankel_1
wrt the argument z.
Examples:
Numerical evaluation:
(%i1) hankel_1(1,0.5); (%o1) 0.24226845767487 - 1.471472392670243 %i
(%i2) hankel_1(1,0.5+%i); (%o2) - 0.25582879948621 %i - 0.23957560188301
Expansion of hankel_1
when besselexpand
is true
:
(%i1) hankel_1(1/2,z),besselexpand:true; sqrt(2) sin(z) - sqrt(2) %i cos(z) (%o1) ---------------------------------- sqrt(%pi) sqrt(z)
Derivative of hankel_1
wrt the argument z. The derivative wrt the
order v is not supported. Maxima returns a noun form:
(%i1) diff(hankel_1(v,z),z); hankel_1(v - 1, z) - hankel_1(v + 1, z) (%o1) --------------------------------------- 2
(%i2) diff(hankel_1(v,z),v); d (%o2) -- (hankel_1(v, z)) dv
Categories: Bessel functions Special functions
The Hankel function of the second kind of order v and argument z
(A&S 9.1.4). hankel_2
is defined as
bessel_j(v,z) - %i * bessel_y(v,z)
Maxima evaluates hankel_2
numerically for a complex order v and
complex argument z in float precision. The numerical evaluation in
bigfloat precision is not supported.
When besselexpand
is true
, hankel_2
is expanded in terms
of elementary functions when the order v is half of an odd integer.
See besselexpand
.
Maxima knows the derivative of hankel_2
wrt the argument z.
For examples see hankel_1
.
Categories: Bessel functions Special functions
Default value: false
Controls expansion of the Bessel functions when the order is half of
an odd integer. In this case, the Bessel functions can be expanded
in terms of other elementary functions. When besselexpand
is true
,
the Bessel function is expanded.
(%i1) besselexpand: false$ (%i2) bessel_j (3/2, z); 3 (%o2) bessel_j(-, z) 2 (%i3) besselexpand: true$ (%i4) bessel_j (3/2, z); sin(z) cos(z) sqrt(2) sqrt(z) (------ - ------) 2 z z (%o4) --------------------------------- sqrt(%pi)
The scaled modified Bessel function of the first kind of order
v and argument z. That is, scaled_bessel_i(v,z) =
exp(-abs(z))*bessel_i(v, z). This function is particularly useful
for calculating bessel_i for large z, which is large.
However, maxima does not otherwise know much about this function. For
symbolic work, it is probably preferable to work with the expression
exp(-abs(z))*bessel_i(v, z)
.
Categories: Bessel functions
Identical to scaled_bessel_i(0,z)
.
Categories: Bessel functions Special functions
Identical to scaled_bessel_i(1,z)
.
Lommel’s little s[u,v](z) function. Probably Gradshteyn & Ryzhik 8.570.1.
Next: Gamma and factorial Functions, Previous: Bessel Functions, Up: Special Functions [Contents][Index]
The Airy functions Ai(x) and Bi(x) are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Section 10.4.
y = Ai(x)
and y = Bi(x)
are two linearly independent solutions
of the Airy differential equation diff (y(x), x, 2) - x y(x) = 0
.
If the argument x
is a real or complex floating point
number, the numerical value of the function is returned.
The Airy function Ai(x). (A&S 10.4.2)
The derivative diff (airy_ai(x), x)
is airy_dai(x)
.
See also airy_bi
, airy_dai
, airy_dbi
.
Categories: Airy functions Special functions
The derivative of the Airy function Ai airy_ai(x)
.
See airy_ai
.
Categories: Airy functions Special functions
The Airy function Bi(x). (A&S 10.4.3)
The derivative diff (airy_bi(x), x)
is airy_dbi(x)
.
See airy_ai
, airy_dbi
.
Categories: Airy functions Special functions
The derivative of the Airy Bi function airy_bi(x)
.
See airy_ai
and airy_bi
.
Categories: Airy functions Special functions
Next: Exponential Integrals, Previous: Airy Functions, Up: Special Functions [Contents][Index]
The gamma function and the related beta, psi and incomplete gamma functions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 6.
Bigfloat version of the factorial (shifted gamma) function. The second argument is how many digits to retain and return, it’s a good idea to request a couple of extra.
Categories: Gamma and factorial functions Numerical evaluation
bfpsi
is the polygamma function of real argument z and integer
order n. bfpsi0
is the digamma function.
bfpsi0 (z, fpprec)
is equivalent to
bfpsi (0, z, fpprec)
.
These functions return bigfloat values. fpprec is the bigfloat precision of the return value.
Categories: Gamma and factorial functions Numerical evaluation
Complex bigfloat factorial.
load ("bffac")
loads this function.
The basic definition of the gamma function (A&S 6.1.1) is
inf / [ z - 1 - t gamma(z) = I t %e dt ] / 0
Maxima simplifies gamma
for positive integer and positive and negative
rational numbers. For half integral values the result is a rational number times
sqrt(%pi)
. The simplification for integer values is controlled by
factlim
. For integers greater than factlim
the numerical result of
the factorial function, which is used to calculate gamma
, will overflow.
The simplification for rational numbers is controlled by gammalim
to
avoid internal overflow. See factlim
and gammalim
.
For negative integers gamma
is not defined.
Maxima can evalute gamma
numerically for real and complex values in float
and bigfloat precision.
gamma
has mirror symmetry.
When gamma_expand
is true
, Maxima expands gamma
for
arguments z+n
and z-n
where n
is an integer.
Maxima knows the derivate of gamma
.
Examples:
Simplification for integer, half integral, and rational numbers:
(%i1) map('gamma,[1,2,3,4,5,6,7,8,9]); (%o1) [1, 1, 2, 6, 24, 120, 720, 5040, 40320] (%i2) map('gamma,[1/2,3/2,5/2,7/2]); sqrt(%pi) 3 sqrt(%pi) 15 sqrt(%pi) (%o2) [sqrt(%pi), ---------, -----------, ------------] 2 4 8 (%i3) map('gamma,[2/3,5/3,7/3]); 2 1 2 gamma(-) 4 gamma(-) 2 3 3 (%o3) [gamma(-), ----------, ----------] 3 3 9
Numerical evaluation for real and complex values:
(%i4) map('gamma,[2.5,2.5b0]); (%o4) [1.329340388179137, 1.3293403881791370205b0] (%i5) map('gamma,[1.0+%i,1.0b0+%i]); (%o5) [0.498015668118356 - .1549498283018107 %i, 4.9801566811835604272b-1 - 1.5494982830181068513b-1 %i]
gamma
has mirror symmetry:
(%i6) declare(z,complex)$ (%i7) conjugate(gamma(z)); (%o7) gamma(conjugate(z))
Maxima expands gamma(z+n)
and gamma(z-n)
, when gamma_expand
is true
:
(%i8) gamma_expand:true$ (%i9) [gamma(z+1),gamma(z-1),gamma(z+2)/gamma(z+1)]; gamma(z) (%o9) [z gamma(z), --------, z + 1] z - 1
The deriviative of gamma
:
(%i10) diff(gamma(z),z); (%o10) psi (z) gamma(z) 0
See also makegamma
.
The Euler-Mascheroni constant is %gamma
.
Categories: Gamma and factorial functions Special functions
The natural logarithm of the gamma function.
Categories: Gamma and factorial functions Special functions
The lower incomplete gamma function (A&S 6.5.2):
z / [ a - 1 - t gamma_incomplete_lower(a, z) = I t %e dt ] / 0
See also gamma_incomplete
(upper incomplete gamma function).
Categories: Gamma and factorial functions Special functions
The incomplete upper gamma function (A&S 6.5.3):
inf / [ a - 1 - t gamma_incomplete(a, z) = I t %e dt ] / z
See also gamma_expand
for controlling how
gamma_incomplete
is expressed in terms of elementary functions
and erfc
.
Also see the related functions gamma_incomplete_regularized
and
gamma_incomplete_generalized
.
Categories: Gamma and factorial functions Special functions
The regularized incomplete upper gamma function (A&S 6.5.1):
gamma_incomplete_regularized(a, z) = gamma_incomplete(a, z) ---------------------- gamma(a)
See also gamma_expand
for controlling how
gamma_incomplete
is expressed in terms of elementary functions
and erfc
.
Also see gamma_incomplete
.
Categories: Gamma and factorial functions Special functions
The generalized incomplete gamma function.
gamma_incomplete_generalized(a, z1, z2) = z2 / [ a - 1 - t I t %e dt ] / z1
Also see gamma_incomplete
and gamma_incomplete_regularized
.
Categories: Gamma and factorial functions Special functions
Default value: false
gamma_expand
controls expansion of gamma_incomplete
.
When gamma_expand
is true
, gamma_incomplete(v,z)
is expanded in terms of
z
, exp(z)
, and erfc(z)
when possible.
(%i1) gamma_incomplete(2,z); (%o1) gamma_incomplete(2, z) (%i2) gamma_expand:true; (%o2) true (%i3) gamma_incomplete(2,z); - z (%o3) (z + 1) %e
(%i4) gamma_incomplete(3/2,z); - z sqrt(%pi) erfc(sqrt(z)) (%o4) sqrt(z) %e + ----------------------- 2
Default value: 10000
gammalim
controls simplification of the gamma
function for integral and rational number arguments. If the absolute
value of the argument is not greater than gammalim
, then
simplification will occur. Note that the factlim
switch controls
simplification of the result of gamma
of an integer argument as well.
Transforms instances of binomial, factorial, and beta functions in expr into gamma functions.
See also makefact
.
Categories: Gamma and factorial functions
The beta function is defined as gamma(a) gamma(b)/gamma(a+b)
(A&S 6.2.1).
Maxima simplifies the beta function for positive integers and rational
numbers, which sum to an integer. When beta_args_sum_to_integer
is
true
, Maxima simplifies also general expressions which sum to an integer.
For a or b equal to zero the beta function is not defined.
In general the beta function is not defined for negative integers as an argument. The exception is for a=-n, n a positive integer and b a positive integer with b<=n, it is possible to define an analytic continuation. Maxima gives for this case a result.
When beta_expand
is true
, expressions like beta(a+n,b)
and
beta(a-n,b)
or beta(a,b+n)
and beta(a,b-n)
with n
an integer are simplified.
Maxima can evaluate the beta function for real and complex values in float and
bigfloat precision. For numerical evaluation Maxima uses log_gamma
:
- log_gamma(b + a) + log_gamma(b) + log_gamma(a) %e
Maxima knows that the beta function is symmetric and has mirror symmetry.
Maxima knows the derivatives of the beta function with respect to a or b.
To express the beta function as a ratio of gamma functions see makegamma
.
Examples:
Simplification, when one of the arguments is an integer:
(%i1) [beta(2,3),beta(2,1/3),beta(2,a)]; 1 9 1 (%o1) [--, -, ---------] 12 4 a (a + 1)
Simplification for two rational numbers as arguments which sum to an integer:
(%i2) [beta(1/2,5/2),beta(1/3,2/3),beta(1/4,3/4)]; 3 %pi 2 %pi (%o2) [-----, -------, sqrt(2) %pi] 8 sqrt(3)
When setting beta_args_sum_to_integer
to true
more general
expression are simplified, when the sum of the arguments is an integer:
(%i3) beta_args_sum_to_integer:true$ (%i4) beta(a+1,-a+2); %pi (a - 1) a (%o4) ------------------ 2 sin(%pi (2 - a))
The possible results, when one of the arguments is a negative integer:
(%i5) [beta(-3,1),beta(-3,2),beta(-3,3)]; 1 1 1 (%o5) [- -, -, - -] 3 6 3
beta(a+n,b)
or beta(a-n)
with n
an integer simplifies when
beta_expand
is true
:
(%i6) beta_expand:true$ (%i7) [beta(a+1,b),beta(a-1,b),beta(a+1,b)/beta(a,b+1)]; a beta(a, b) beta(a, b) (b + a - 1) a (%o7) [------------, ----------------------, -] b + a a - 1 b
Beta is not defined, when one of the arguments is zero:
(%i7) beta(0,b); beta: expected nonzero arguments; found 0, b -- an error. To debug this try debugmode(true);
Numercial evaluation for real and complex arguments in float or bigfloat precision:
(%i8) beta(2.5,2.3); (%o8) .08694748611299981 (%i9) beta(2.5,1.4+%i); (%o9) 0.0640144950796695 - .1502078053286415 %i (%i10) beta(2.5b0,2.3b0); (%o10) 8.694748611299969b-2 (%i11) beta(2.5b0,1.4b0+%i); (%o11) 6.401449507966944b-2 - 1.502078053286415b-1 %i
Beta is symmetric and has mirror symmetry:
(%i14) beta(a,b)-beta(b,a); (%o14) 0 (%i15) declare(a,complex,b,complex)$ (%i16) conjugate(beta(a,b)); (%o16) beta(conjugate(a), conjugate(b))
The derivative of the beta function wrt a
:
(%i17) diff(beta(a,b),a); (%o17) - beta(a, b) (psi (b + a) - psi (a)) 0 0
Categories: Gamma and factorial functions
The basic definition of the incomplete beta function (A&S 6.6.1) is
z / [ b - 1 a - 1 I (1 - t) t dt ] / 0
This definition is possible for realpart(a)>0 and realpart(b)>0 and abs(z)<1. For other values the incomplete beta function can be defined through a generalized hypergeometric function:
gamma(a) hypergeometric_generalized([a, 1 - b], [a + 1], z) z
(See functions.wolfram.com for a complete definition of the incomplete beta function.)
For negative integers a = -n and positive integers b=m with m<=n the incomplete beta function is defined through
m - 1 k ==== (1 - m) z n - 1 \ k z > ----------- / k! (n - k) ==== k = 0
Maxima uses this definition to simplify beta_incomplete
for a a
negative integer.
For a a positive integer, beta_incomplete
simplifies for any
argument b and z and for b a positive integer for any
argument a and z, with the exception of a a negative integer.
For z=0 and realpart(a)>0, beta_incomplete
has the
specific value zero. For z=1 and realpart(b)>0,
beta_incomplete
simplifies to the beta function beta(a,b)
.
Maxima evaluates beta_incomplete
numerically for real and complex values
in float or bigfloat precision. For the numerical evaluation an expansion of the
incomplete beta function in continued fractions is used.
When the option variable beta_expand
is true
, Maxima expands
expressions like beta_incomplete(a+n,b,z)
and
beta_incomplete(a-n,b,z)
where n is a positive integer.
Maxima knows the derivatives of beta_incomplete
with respect to the
variables a, b and z and the integral with respect to the
variable z.
Examples:
Simplification for a a positive integer:
(%i1) beta_incomplete(2,b,z); b 1 - (1 - z) (b z + 1) (%o1) ---------------------- b (b + 1)
Simplification for b a positive integer:
(%i2) beta_incomplete(a,2,z); a (a (1 - z) + 1) z (%o2) ------------------ a (a + 1)
Simplification for a and b a positive integer:
(%i3) beta_incomplete(3,2,z);
3 (3 (1 - z) + 1) z (%o3) ------------------ 12
a is a negative integer and b<=(-a), Maxima simplifies:
(%i4) beta_incomplete(-3,1,z); 1 (%o4) - ---- 3 3 z
For the specific values z=0 and z=1, Maxima simplifies:
(%i5) assume(a>0,b>0)$ (%i6) beta_incomplete(a,b,0); (%o6) 0 (%i7) beta_incomplete(a,b,1); (%o7) beta(a, b)
Numerical evaluation in float or bigfloat precision:
(%i8) beta_incomplete(0.25,0.50,0.9); (%o8) 4.594959440269333 (%i9) fpprec:25$ (%i10) beta_incomplete(0.25,0.50,0.9b0); (%o10) 4.594959440269324086971203b0
For abs(z)>1 beta_incomplete
returns a complex result:
(%i11) beta_incomplete(0.25,0.50,1.7); (%o11) 5.244115108584249 - 1.45518047787844 %i
Results for more general complex arguments:
(%i14) beta_incomplete(0.25+%i,1.0+%i,1.7+%i); (%o14) 2.726960675662536 - .3831175704269199 %i (%i15) beta_incomplete(1/2,5/4*%i,2.8+%i); (%o15) 13.04649635168716 %i - 5.802067956270001 (%i16)
Expansion, when beta_expand
is true
:
(%i23) beta_incomplete(a+1,b,z),beta_expand:true; b a a beta_incomplete(a, b, z) (1 - z) z (%o23) -------------------------- - ----------- b + a b + a (%i24) beta_incomplete(a-1,b,z),beta_expand:true; b a - 1 beta_incomplete(a, b, z) (- b - a + 1) (1 - z) z (%o24) -------------------------------------- - --------------- 1 - a 1 - a
Derivative and integral for beta_incomplete
:
(%i34) diff(beta_incomplete(a, b, z), z);
b - 1 a - 1 (%o34) (1 - z) z
(%i35) integrate(beta_incomplete(a, b, z), z); b a (1 - z) z (%o35) ----------- + beta_incomplete(a, b, z) z b + a a beta_incomplete(a, b, z) - -------------------------- b + a (%i36) factor(diff(%, z)); (%o36) beta_incomplete(a, b, z)
Categories: Gamma and factorial functions
The regularized incomplete beta function (A&S 6.6.2), defined as
beta_incomplete_regularized(a, b, z) = beta_incomplete(a, b, z) ------------------------ beta(a, b)
As for beta_incomplete
this definition is not complete. See
functions.wolfram.com for a complete definition of
beta_incomplete_regularized
.
beta_incomplete_regularized
simplifies a or b a positive
integer.
For z=0 and realpart(a)>0, beta_incomplete_regularized
has
the specific value 0. For z=1 and realpart(b)>0,
beta_incomplete_regularized
simplifies to 1.
Maxima can evaluate beta_incomplete_regularized
for real and complex
arguments in float and bigfloat precision.
When beta_expand
is true
, Maxima expands
beta_incomplete_regularized
for arguments a+n or a-n,
where n is an integer.
Maxima knows the derivatives of beta_incomplete_regularized
with respect
to the variables a, b, and z and the integral with respect to
the variable z.
Examples:
Simplification for a or b a positive integer:
(%i1) beta_incomplete_regularized(2,b,z); b (%o1) 1 - (1 - z) (b z + 1) (%i2) beta_incomplete_regularized(a,2,z); a (%o2) (a (1 - z) + 1) z (%i3) beta_incomplete_regularized(3,2,z); 3 (%o3) (3 (1 - z) + 1) z
For the specific values z=0 and z=1, Maxima simplifies:
(%i4) assume(a>0,b>0)$ (%i5) beta_incomplete_regularized(a,b,0); (%o5) 0 (%i6) beta_incomplete_regularized(a,b,1); (%o6) 1
Numerical evaluation for real and complex arguments in float and bigfloat precision:
(%i7) beta_incomplete_regularized(0.12,0.43,0.9); (%o7) .9114011367359802 (%i8) fpprec:32$ (%i9) beta_incomplete_regularized(0.12,0.43,0.9b0); (%o9) 9.1140113673598075519946998779975b-1 (%i10) beta_incomplete_regularized(1+%i,3/3,1.5*%i); (%o10) .2865367499935403 %i - 0.122995963334684 (%i11) fpprec:20$ (%i12) beta_incomplete_regularized(1+%i,3/3,1.5b0*%i); (%o12) 2.8653674999354036142b-1 %i - 1.2299596333468400163b-1
Expansion, when beta_expand
is true
:
(%i13) beta_incomplete_regularized(a+1,b,z); b a (1 - z) z (%o13) beta_incomplete_regularized(a, b, z) - ------------ a beta(a, b) (%i14) beta_incomplete_regularized(a-1,b,z); (%o14) beta_incomplete_regularized(a, b, z) b a - 1 (1 - z) z - ---------------------- beta(a, b) (b + a - 1)
The derivative and the integral wrt z:
(%i15) diff(beta_incomplete_regularized(a,b,z),z); b - 1 a - 1 (1 - z) z (%o15) ------------------- beta(a, b) (%i16) integrate(beta_incomplete_regularized(a,b,z),z); (%o16) beta_incomplete_regularized(a, b, z) z b a (1 - z) z a (beta_incomplete_regularized(a, b, z) - ------------) a beta(a, b) - ------------------------------------------------------- b + a
Categories: Gamma and factorial functions
The basic definition of the generalized incomplete beta function is
z2 / [ b - 1 a - 1 I (1 - t) t dt ] / z1
Maxima simplifies beta_incomplete_regularized
for a and b
a positive integer.
For realpart(a)>0 and z1=0 or z2=0, Maxima simplifies
beta_incomplete_generalized
to beta_incomplete
. For
realpart(b)>0 and z1=1 or z2=1, Maxima simplifies to an
expression with beta
and beta_incomplete
.
Maxima evaluates beta_incomplete_regularized
for real and complex values
in float and bigfloat precision.
When beta_expand
is true
, Maxima expands
beta_incomplete_generalized
for a+n and a-n, n a
positive integer.
Maxima knows the derivative of beta_incomplete_generalized
with respect
to the variables a, b, z1, and z2 and the integrals with
respect to the variables z1 and z2.
Examples:
Maxima simplifies beta_incomplete_generalized
for a and b a
positive integer:
(%i1) beta_incomplete_generalized(2,b,z1,z2); b b (1 - z1) (b z1 + 1) - (1 - z2) (b z2 + 1) (%o1) ------------------------------------------- b (b + 1) (%i2) beta_incomplete_generalized(a,2,z1,z2);
a a (a (1 - z2) + 1) z2 - (a (1 - z1) + 1) z1 (%o2) ------------------------------------------- a (a + 1)
(%i3) beta_incomplete_generalized(3,2,z1,z2); 2 2 2 2 (1 - z1) (3 z1 + 2 z1 + 1) - (1 - z2) (3 z2 + 2 z2 + 1) (%o3) ----------------------------------------------------------- 12
Simplification for specific values z1=0, z2=0, z1=1, or z2=1:
(%i4) assume(a > 0, b > 0)$ (%i5) beta_incomplete_generalized(a,b,z1,0); (%o5) - beta_incomplete(a, b, z1) (%i6) beta_incomplete_generalized(a,b,0,z2); (%o6) - beta_incomplete(a, b, z2) (%i7) beta_incomplete_generalized(a,b,z1,1); (%o7) beta(a, b) - beta_incomplete(a, b, z1) (%i8) beta_incomplete_generalized(a,b,1,z2); (%o8) beta_incomplete(a, b, z2) - beta(a, b)
Numerical evaluation for real arguments in float or bigfloat precision:
(%i9) beta_incomplete_generalized(1/2,3/2,0.25,0.31); (%o9) .09638178086368676 (%i10) fpprec:32$ (%i10) beta_incomplete_generalized(1/2,3/2,0.25,0.31b0); (%o10) 9.6381780863686935309170054689964b-2
Numerical evaluation for complex arguments in float or bigfloat precision:
(%i11) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31); (%o11) - .09625463003205376 %i - .003323847735353769 (%i12) fpprec:20$ (%i13) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31b0); (%o13) - 9.6254630032054178691b-2 %i - 3.3238477353543591914b-3
Expansion for a+n or a-n, n a positive integer, when
beta_expand
is true
:
(%i14) beta_expand:true$ (%i15) beta_incomplete_generalized(a+1,b,z1,z2); b a b a (1 - z1) z1 - (1 - z2) z2 (%o15) ----------------------------- b + a a beta_incomplete_generalized(a, b, z1, z2) + ------------------------------------------- b + a (%i16) beta_incomplete_generalized(a-1,b,z1,z2); beta_incomplete_generalized(a, b, z1, z2) (- b - a + 1) (%o16) ------------------------------------------------------- 1 - a b a - 1 b a - 1 (1 - z2) z2 - (1 - z1) z1 - ------------------------------------- 1 - a
Derivative wrt the variable z1 and integrals wrt z1 and z2:
(%i17) diff(beta_incomplete_generalized(a,b,z1,z2),z1); b - 1 a - 1 (%o17) - (1 - z1) z1 (%i18) integrate(beta_incomplete_generalized(a,b,z1,z2),z1); (%o18) beta_incomplete_generalized(a, b, z1, z2) z1 + beta_incomplete(a + 1, b, z1) (%i19) integrate(beta_incomplete_generalized(a,b,z1,z2),z2); (%o19) beta_incomplete_generalized(a, b, z1, z2) z2 - beta_incomplete(a + 1, b, z2)
Categories: Gamma and factorial functions
Default value: false
When beta_expand
is true
, beta(a,b)
and related
functions are expanded for arguments like a+n or a-n,
where n is an integer.
Default value: false
When beta_args_sum_to_integer
is true
, Maxima simplifies
beta(a,b)
, when the arguments a and b sum to an integer.
The derivative of log (gamma (x))
of order n+1
.
Thus, psi[0](x)
is the first derivative,
psi[1](x)
is the second derivative, etc.
Maxima does not know how, in general, to compute a numerical value of
psi
, but it can compute some exact values for rational args.
Several variables control what range of rational args psi
will
return an exact value, if possible. See maxpsiposint
,
maxpsinegint
, maxpsifracnum
, and maxpsifracdenom
.
That is, x must lie between maxpsinegint
and
maxpsiposint
. If the absolute value of the fractional part of
x is rational and has a numerator less than maxpsifracnum
and has a denominator less than maxpsifracdenom
, psi
will return an exact value.
The function bfpsi
in the bffac
package can compute
numerical values.
Categories: Gamma and factorial functions
Default value: 20
maxpsiposint
is the largest positive value for which
psi[n](x)
will try to compute an exact value.
Categories: Gamma and factorial functions
Default value: -10
maxpsinegint
is the most negative value for which
psi[n](x)
will try to compute an exact value. That is if
x is less than maxnegint
, psi[n](x)
will not
return simplified answer, even if it could.
Categories: Gamma and factorial functions
Default value: 6
Let x be a rational number less than one of the form p/q
.
If p
is greater than maxpsifracnum
, then
psi[n](x)
will not try to return a simplified
value.
Categories: Gamma and factorial functions
Default value: 6
Let x be a rational number less than one of the form p/q
.
If q
is greater than maxpsifracdenom
, then
psi[n](x)
will not try to return a simplified
value.
Categories: Gamma and factorial functions
Transforms instances of binomial, gamma, and beta functions in expr into factorials.
See also makegamma
.
Categories: Gamma and factorial functions
Returns the numerical factor multiplying the expression expr, which should be a single term.
content
returns the greatest common divisor (gcd) of all terms in a sum.
(%i1) gamma (7/2); 15 sqrt(%pi) (%o1) ------------ 8 (%i2) numfactor (%); 15 (%o2) -- 8
Categories: Expressions
Next: Error Function, Previous: Gamma and factorial Functions, Up: Special Functions [Contents][Index]
The Exponential Integral and related funtions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 5
The Exponential Integral E1(z) (A&S 5.1.1) defined as
Categories: Exponential Integrals Special functions
The Exponential Integral Ei(z) (A&S 5.1.2)
Categories: Exponential Integrals Special functions
The Exponential Integral Li(z) (A&S 5.1.3)
Categories: Exponential Integrals Special functions
The Exponential Integral En(z) (A&S 5.1.4) defined as
Categories: Exponential Integrals Special functions
The Exponential Integral Si(z) (A&S 5.2.1) defined as
Categories: Exponential Integrals Special functions
The Exponential Integral Ci(z) (A&S 5.2.2) defined as
Categories: Exponential Integrals Special functions
The Exponential Integral Shi(z) (A&S 5.2.3) defined as
Categories: Exponential Integrals Special functions
The Exponential Integral Chi(z) (A&S 5.2.4) defined as
Categories: Exponential Integrals Special functions
Default value: false
Change the representation of one of the exponential integrals, expintegral_e(m, z), expintegral_e1, or expintegral_ei to an equivalent form if possible.
Possible values for expintrep are false, gamma_incomplete, expintegral_e1, expintegral_ei, expintegral_li, expintegral_trig, or expintegral_hyp.
false means that the representation is not changed. Other values indicate the representation is to be changed to use the function specified where expintegral_trig means expintegral_si, expintegral_ci, and expintegral_hyp means expintegral_shi or expintegral_chi.
Categories: Exponential Integrals
Default value: false
Expand the Exponential Integral E[n](z) for half integral values in terms of Erfc or Erf and for positive integers in terms of Ei
Next: Struve Functions, Previous: Exponential Integrals, Up: Special Functions [Contents][Index]
The Error function and related funtions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 7
The Error Function erf(z) (A&S 7.1.1)
See also flag erfflag
.
The Complementary Error Function erfc(z) (A&S 7.1.2)
erfc(z) = 1-erf(z)
The Imaginary Error Function.
erfi(z) = -%i*erf(%i*z)
Generalized Error function Erf(z1,z2)
The Fresnel Integral C(z) = integrate(cos((%pi/2)*t^2),t,0,z). (A&S 7.3.1)
The simplification fresnel_c(-x) = -fresnel_c(x) is applied when
flag trigsign
is true.
The simplification fresnel_c(%i*x) = %i*fresnel_c(x) is applied when
flag %iargs
is true.
See flags erf_representation
and hypergeometric_representation
.
The Fresnel Integral S(z) = integrate(sin((%pi/2)*t^2),t,0,z). (A&S 7.3.2)
The simplification fresnel_s(-x) = -fresnel_s(x) is applied when
flag trigsign
is true.
The simplification fresnel_s(%i*x) = -%i*fresnel_s(x) is applied when
flag %iargs
is true.
See flags erf_representation
and hypergeometric_representation
.
Default value: false
When T erfc, erfi, erf_generalized, fresnel_s and fresnel_c are transformed to erf.
Default value: false
Enables transformation to a Hypergeometric representation for fresnel_s and fresnel_c
Next: Hypergeometric Functions, Previous: Error Function, Up: Special Functions [Contents][Index]
The Struve functions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 12.
The Struve Function H of order v and argument z. (A&S 12.1.1)
Categories: Special functions
The Modified Struve Function L of order v and argument z. (A&S 12.2.1)
Categories: Special functions
Next: Parabolic Cylinder Functions, Previous: Struve Functions, Up: Special Functions [Contents][Index]
The Hypergeometric Functions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapters 13 and 15.
Maxima has very limited knowledge of these functions. They
can be returned from function hgfred
.
Whittaker M function
M[k,u](z) = exp(-z/2)*z^(1/2+u)*M(1/2+u-k,1+2*u,z)
.
(A&S 13.1.32)
Whittaker W function. (A&S 13.1.33)
The pFq(a1,a2,..ap;b1,b2,..bq;z) hypergeometric function,
where a
a list of length p
and
b
a list of length q
.
The hypergeometric function. Unlike Maxima’s %f
hypergeometric
function, the function hypergeometric
is a simplifying
function; also, hypergeometric
supports complex double and
big floating point evaluation. For the Gauss hypergeometric function,
that is p = 2 and q = 1, floating point evaluation
outside the unit circle is supported, but in general, it is not
supported.
When the option variable expand_hypergeometric
is true (default
is false) and one of the arguments a1
through ap
is a
negative integer (a polynomial case), hypergeometric
returns an
expanded polynomial.
Examples:
(%i1) hypergeometric([],[],x); (%o1) %e^x
Polynomial cases automatically expand when expand_hypergeometric
is true:
(%i2) hypergeometric([-3],[7],x); (%o2) hypergeometric([-3],[7],x) (%i3) hypergeometric([-3],[7],x), expand_hypergeometric : true; (%o3) -x^3/504+3*x^2/56-3*x/7+1
Both double float and big float evaluation is supported:
(%i4) hypergeometric([5.1],[7.1 + %i],0.42); (%o4) 1.346250786375334 - 0.0559061414208204 %i (%i5) hypergeometric([5,6],[8], 5.7 - %i); (%o5) .007375824009774946 - .001049813688578674 %i (%i6) hypergeometric([5,6],[8], 5.7b0 - %i), fpprec : 30; (%o6) 7.37582400977494674506442010824b-3 - 1.04981368857867315858055393376b-3 %i
Next: Functions and Variables for Special Functions, Previous: Hypergeometric Functions, Up: Special Functions [Contents][Index]
The Parabolic Cylinder Functions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 19.
Maxima has very limited knowledge of these functions. They
can be returned from function hgfred
.
The parabolic cylinder function parabolic_cylinder_d(v,z)
. (A&S 19.3.1)
Previous: Parabolic Cylinder Functions, Up: Special Functions [Contents][Index]
Compute the Laplace transform of expr with respect to the variable t. The integrand expr may contain special functions. The parameter s maybe be named something else; it is determined automatically, as the examples below show where p is used in some places.
The following special functions are handled by specint
: incomplete gamma
function, error functions (but not the error function erfi
, it is easy to
transform erfi
e.g. to the error function erf
), exponential
integrals, bessel functions (including products of bessel functions), hankel
functions, hermite and the laguerre polynomials.
Furthermore, specint
can handle the hypergeometric function
%f[p,q]([],[],z)
, the whittaker function of the first kind
%m[u,k](z)
and of the second kind %w[u,k](z)
.
The result may be in terms of special functions and can include unsimplified hypergeometric functions.
When laplace
fails to find a Laplace transform, specint
is called.
Because laplace
knows more general rules for Laplace transforms, it is
preferable to use laplace
and not specint
.
demo("hypgeo")
displays several examples of Laplace transforms computed by
specint
.
Examples:
(%i1) assume (p > 0, a > 0)$
(%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t); sqrt(%pi) (%o2) ------------ a 3/2 2 (p + -) 4
(%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2)) * exp(-p*t), t); - a/p sqrt(a) %e (%o3) --------------- 2 p
Examples for exponential integrals:
(%i4) assume(s>0,a>0,s-a>0)$ (%i5) ratsimp(specint(%e^(a*t) *(log(a)+expintegral_e1(a*t))*%e^(-s*t),t)); log(s) (%o5) ------ s - a (%i6) logarc:true$ (%i7) gamma_expand:true$ radcan(specint((cos(t)*expintegral_si(t) -sin(t)*expintegral_ci(t))*%e^(-s*t),t)); log(s) (%o8) ------ 2 s + 1 ratsimp(specint((2*t*log(a)+2/a*sin(a*t) -2*t*expintegral_ci(a*t))*%e^(-s*t),t)); 2 2 log(s + a ) (%o9) ------------ 2 s
Results when using the expansion of gamma_incomplete
and when changing
the representation to expintegral_e1
:
(%i10) assume(s>0)$ (%i11) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t); 1 gamma_incomplete(-, k s) 2 (%o11) ------------------------ sqrt(%pi) sqrt(s) (%i12) gamma_expand:true$ (%i13) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t); erfc(sqrt(k) sqrt(s)) (%o13) --------------------- sqrt(s) (%i14) expintrep:expintegral_e1$ (%i15) ratsimp(specint(1/(t+a)^2*%e^(-s*t),t)); a s a s %e expintegral_e1(a s) - 1 (%o15) - --------------------------------- a
Categories: Laplace transform
hypergeometric_simp
simplifies hypergeometric functions
by applying hgfred
to the arguments of any hypergeometric functions in the expression e.
Only instances of hypergeometric
are affected;
any %f
, %w
, and %m
in the expression e are not affected.
Any unsimplified hypergeometric functions are returned unchanged
(instead of changing to %f
as hgfred
would).
load(hypergeometric);
loads this function.
See also hgfred
.
Examples:
(%i1) load ("hypergeometric") $ (%i2) foo : [hypergeometric([1,1], [2], z), hypergeometric([1/2], [1], z)]; (%o2) [hypergeometric([1, 1], [2], z), 1 hypergeometric([-], [1], z)] 2 (%i3) hypergeometric_simp (foo); log(1 - z) z z/2 (%o3) [- ----------, bessel_i(0, -) %e ] z 2 (%i4) bar : hypergeometric([n], [m], z + 1); (%o4) hypergeometric([n], [m], z + 1) (%i5) hypergeometric_simp (bar); (%o5) hypergeometric([n], [m], z + 1)
Simplify the generalized hypergeometric function in terms of other, simpler, forms. a is a list of numerator parameters and b is a list of the denominator parameters.
If hgfred
cannot simplify the hypergeometric function, it returns
an expression of the form %f[p,q]([a], [b], x)
where p is
the number of elements in a, and q is the number of elements
in b. This is the usual pFq
generalized hypergeometric
function.
(%i1) assume(not(equal(z,0))); (%o1) [notequal(z, 0)] (%i2) hgfred([v+1/2],[2*v+1],2*%i*z); v/2 %i z 4 bessel_j(v, z) gamma(v + 1) %e (%o2) --------------------------------------- v z (%i3) hgfred([1,1],[2],z); log(1 - z) (%o3) - ---------- z (%i4) hgfred([a,a+1/2],[3/2],z^2); 1 - 2 a 1 - 2 a (z + 1) - (1 - z) (%o4) ------------------------------- 2 (1 - 2 a) z
It can be beneficial to load orthopoly too as the following example shows. Note that L is the generalized Laguerre polynomial.
(%i5) load(orthopoly)$ (%i6) hgfred([-2],[a],z);
(a - 1) 2 L (z) 2 (%o6) ------------- a (a + 1)
(%i7) ev(%); 2 z 2 z (%o7) --------- - --- + 1 a (a + 1) a
The principal branch of Lambert’s W function W(z), the solution of
z = W(z) * exp(W(z))
. (DLMF 4.13)
The k-th branch of Lambert’s W function W(z), the solution of
z = W(z) * exp(W(z))
. (DLMF 4.13)
The principal branch, denoted Wp(z) in DLMF, is lambert_w(z) = generalized_lambert_w(0,z)
.
The other branch with real values, denoted Wm(z) in DLMF, is generalized_lambert_w(-1,z)
.
The Plasma Dispersion Function
nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z))
Returns realpart(nzeta(z))
.
Returns imagpart(nzeta(z))
.
Previous: Parabolic Cylinder Functions, Up: Special Functions [Contents][Index]