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.
(%i1) bffac(1/2,16); (%o1) 8.862269254527584b-1 (%i2) (1/2)!,numer; (%o2) 0.886226925452758 (%i3) bffac(1/2,32); (%o3) 8.862269254527580136490837416707b-1
bfpsi
is the polygamma function of real argument z and
integer order n. See psi for further
information. 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.
(%i1) bfpsi0(1/3, 15); (%o1) - 3.13203378002081b0 (%i2) bfpsi0(1/3, 32); (%o2) - 3.1320337800208063229964190742873b0 (%i3) bfpsi(0,1/3,32); (%o3) - 3.1320337800208063229964190742873b0 (%i4) psi[0](1/3); 3 log(3) %pi (%o4) (- --------) - --------- - %gamma 2 2 sqrt(3) (%i5) float(%); (%o5) - 3.132033780020806
Complex bigfloat factorial.
load ("bffac")
loads this function.
(%i1) cbffac(1+%i,16); (%o1) 3.430658398165453b-1 %i + 6.529654964201666b-1 (%i2) (1+%i)!,numer; (%o2) 0.3430658398165453 %i + 0.6529654964201667
The basic definition of the gamma function (DLMF 5.2.E1 and A&S eqn 6.1.1) is
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 evaluate 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 derivative 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 derivative of gamma
:
(%i10) diff(gamma(z),z); (%o10) psi (z) gamma(z) 0
See also makegamma
.
The Euler-Mascheroni constant is %gamma
.
The natural logarithm of the gamma function.
(%i1) gamma(6); (%o1) 120 (%i2) log_gamma(6); (%o2) log(120) (%i3) log_gamma(0.5); (%o3) 0.5723649429247004
The lower incomplete gamma function (DLMF 8.2.E1 and A&S eqn 6.5.2):
See also gamma_incomplete
(upper incomplete gamma function).
The incomplete upper gamma function (DLMF 8.2.E2 and A&S eqn 6.5.3):
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
.
The regularized incomplete upper gamma function (DLMF 8.2.E4):
See also gamma_expand
for controlling how
gamma_incomplete
is expressed in terms of elementary functions
and erfc
.
Also see gamma_incomplete
.
The generalized incomplete gamma function.
Also see gamma_incomplete
and gamma_incomplete_regularized
.
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 gamma_incomplete
or erfc
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
(%i5) gamma_incomplete(4/3,z); 1 gamma_incomplete(-, z) 1/3 - z 3 (%o5) z %e + ---------------------- 3
(%i6) gamma_incomplete(a+2,z); a - z (%o6) z (z + a + 1) %e + a (a + 1) gamma_incomplete(a, z) (%i7) gamma_incomplete(a-2, z); gamma_incomplete(a, z) a - 2 z 1 - z (%o7) ---------------------- - z (--------------- + -----) %e (1 - a) (2 - a) (a - 2) (a - 1) a - 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
.
(%i1) makegamma(binomial(n,k)); gamma(n + 1) (%o1) ----------------------------- gamma(k + 1) gamma(n - k + 1) (%i2) makegamma(x!); (%o2) gamma(x + 1) (%i3) makegamma(beta(a,b)); gamma(a) gamma(b) (%o3) ----------------- gamma(b + a)
The beta function is defined as
(DLMF 5.12.E1 and A&S eqn 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,b)
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);
Numerical 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
The basic definition of the incomplete beta function (DLMF 8.17.E1 and A&S eqn 6.6.1) is
This definition is possible for \({\rm Re}(a) > 0\) and \({\rm Re}(b) > 0\) and \(|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 https://functions.wolfram.com/GammaBetaErf/Beta3/ for a complete definition of the incomplete beta function.)
For negative integers \(a = -n\) and positive integers \(b=m\) with \(m \le n\) the incomplete beta function is defined through
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
\({\rm Re}(a) > 0\)
, beta_incomplete
has the
specific value zero. For \(z=1\) and
\({\rm Re}(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)
The regularized incomplete beta function (DLMF 8.17.E2 and A&S eqn 6.6.2), defined as
As for beta_incomplete
this definition is not complete. See
https://functions.wolfram.com/GammaBetaErf/BetaRegularized/ for a complete definition of
beta_incomplete_regularized
.
beta_incomplete_regularized
simplifies a or b a positive
integer.
For \(z=0\) and
\({\rm Re}(a)>0\)
,
beta_incomplete_regularized
has
the specific value 0. For \(z=1\) and
\({\rm Re}(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
The basic definition of the generalized incomplete beta function is
Maxima simplifies beta_incomplete_regularized
for a and b
a positive integer.
For
\({\rm Re}(a) > 0\)
and
\(z_1 = 0\)
or
\(z_2 = 0\)
, Maxima simplifies
beta_incomplete_generalized
to beta_incomplete
.
For
\({\rm Re}(b) > 0\)
and
\(z_1 = 1\)
or
\(z_2 = 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)
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.
See beta for examples.
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.
See beta for examples.
psi[n](x)
is the polygamma function (DLMF 5.2E2,
DLMF 5.15, A&S eqn 6.3.1 and A&S eqn 6.4.1) defined by
Thus, psi[0](x)
is the first derivative,
psi[1](x)
is the second derivative, etc.
Maxima can compute some exact values for rational args as well for
float and bfloat args. Several variables control what range of
rational args
\(\psi^{(n)}(x)\)
) 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^{(0)}(x)\)
will
return an exact value.
The function bfpsi
in the bffac
package can compute
numerical values.
(%i1) psi[0](.25); (%o1) - 4.227453533376265 (%i2) psi[0](1/4); %pi (%o2) (- 3 log(2)) - --- - %gamma 2 (%i3) float(%); (%o3) - 4.227453533376265 (%i4) psi[2](0.75); (%o4) - 5.30263321633764 (%i5) psi[2](3/4); 1 3 (%o5) psi (-) + 4 %pi 2 4 (%i6) float(%); (%o6) - 5.30263321633764
Default value: 20
maxpsiposint
is the largest positive integer value for
which
\(\psi^{(n)}(m)\)
gives an exact value for
rational \(x\).
(%i1) psi[0](20); 275295799 (%o1) --------- - %gamma 77597520 (%i2) psi[0](21); (%o2) psi (21) 0 (%i3) psi[2](20); 1683118856778495358491487 (%o3) 2 (------------------------- - zeta(3)) 1401731326612193601024000 (%i4) psi[2](21); (%o4) psi (21) 2
Default value: -10
maxpsinegint
is the most negative value for
which
\(\psi^{(0)}(x)\)
will try to compute an exact
value for rational \(x\). That is if \(x\) is less than
maxpsinegint
,
\(\psi^{(n)}(x)\)
will not
return simplified answer, even if it could.
(%i1) psi[0](-100/9); 100 (%o1) psi (- ---) 0 9 (%i2) psi[0](-100/11); 100 %pi 1 5231385863539 (%o2) %pi cot(-------) + psi (--) + ------------- 11 0 11 381905105400 (%i3) psi[2](-100/9); 100 (%o3) psi (- ---) 2 9 (%i4) psi[2](-100/11); 3 100 %pi 2 100 %pi 1 (%o4) 2 %pi cot(-------) csc (-------) + psi (--) 11 11 2 11 74191313259470963498957651385614962459 + -------------------------------------- 27850718060013605318710152732000000
Default value: 6
Let \(x\) be a rational number of the form \(p/q\).
If \(p\) is greater than maxpsifracnum
,
then
\(\psi^{(0)}(x)\)
will not try to
return a simplified value.
(%i1) psi[0](3/4); %pi (%o1) (- 3 log(2)) + --- - %gamma 2 (%i2) psi[2](3/4); 1 3 (%o2) psi (-) + 4 %pi 2 4 (%i3) maxpsifracnum:2; (%o3) 2 (%i4) psi[0](3/4); 3 (%o4) psi (-) 0 4 (%i5) psi[2](3/4); 1 3 (%o5) psi (-) + 4 %pi 2 4
Default value: 6
Let \(x\) be a rational number of the form \(p/q\).
If \(q\) is greater than maxpsifracdenom
,
then
\(\psi^{(0)}(x)\)
will
not try to return a simplified value.
(%i1) psi[0](3/4); %pi (%o1) (- 3 log(2)) + --- - %gamma 2 (%i2) psi[2](3/4); 1 3 (%o2) psi (-) + 4 %pi 2 4 (%i3) maxpsifracdenom:2; (%o3) 2 (%i4) psi[0](3/4); 3 (%o4) psi (-) 0 4 (%i5) psi[2](3/4); 1 3 (%o5) psi (-) + 4 %pi 2 4
Transforms instances of binomial, gamma, and beta functions in expr into factorials.
See also makegamma
.
(%i1) makefact(binomial(n,k)); n! (%o1) ----------- k! (n - k)! (%i2) makefact(gamma(x)); (%o2) (x - 1)! (%i3) makefact(beta(a,b)); (a - 1)! (b - 1)! (%o3) ----------------- (b + a - 1)!
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
Next: Exponential Integrals, Previous: Airy Functions, Up: Special Functions [Contents][Index]