Maxima Manual: Gamma and Factorial Functions

Next: Exponential Integrals, Previous: Airy Functions, Up: Special Functions [Contents][Index]

### 14.4 Gamma and Factorial Functions

The gamma function and the related beta, psi and incomplete gamma functions are defined in Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 6.

Function: bffac (expr, n)

  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

Function: bfpsi (n, z, fpprec)
Function: bfpsi0 (z, fpprec)

  `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

Function: cbffac (z, fpprec)

  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

Function: gamma (z)

  The basic definition of the gamma function (DLMF 5.2.E1 and A&S eqn 6.1.1) is

  $$ \Gamma\left(z\right)=\int_{0}^{\infty }{t^{z-1}\,e^ {- t }\;dt} $$

  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`.

Function: log_gamma (z)

  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

Function: gamma_incomplete_lower (a, z)

  The lower incomplete gamma function (DLMF 8.2.E1 and A&S eqn 6.5.2):

  $$ \gamma\left(a , z\right)=\int_{0}^{z}{t^{a-1}\,e^ {- t }\;dt} $$

  See also `gamma_incomplete` (upper incomplete gamma function).

Function: gamma_incomplete (a, z)

  The incomplete upper gamma function (DLMF 8.2.E2 and A&S eqn 6.5.3):

  $$ \Gamma\left(a , z\right)=\int_{z}^{\infty }{t^{a-1}\,e^ {- t }\;dt} $$

  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`.

Function: gamma_incomplete_regularized (a, z)

  The regularized incomplete upper gamma function (DLMF 8.2.E4):

  $$ Q\left(a , z\right)={{\Gamma\left(a , z\right)}\over{\Gamma\left(a\right)}} $$

  See also `gamma_expand` for controlling how `gamma_incomplete` is expressed in terms of elementary functions and `erfc`.

  Also see `gamma_incomplete`.

Function: gamma_incomplete_generalized (a, z1, z1)

  The generalized incomplete gamma function.

  $$ \Gamma\left(a , z_{1}, z_{2}\right)=\int_{z_{1}}^{z_{2}}{t^{a-1}\,e^ {- t }\;dt} $$

  Also see `gamma_incomplete` and `gamma_incomplete_regularized`.

Option variable: gamma_expand

  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

Option variable: gammalim

  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.

Function: makegamma (expr)

  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)

Function: beta (a, b)

  The beta function is defined as $$ {\rm B}(a, b) = {{\Gamma(a) \Gamma(b)}\over{\Gamma(a+b)}} $$

  (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

Function: beta_incomplete (a, b, z)

  The basic definition of the incomplete beta function (DLMF 8.17.E1 and A&S eqn 6.6.1) is

  $$ {\rm B}_z(a,b) = \int_0^z t^{a-1}(1-t)^{b-1}\; dt $$

  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

  $$ z^{n-1}\sum_{k=0}^{m-1} {{(1-m)_k z^k} \over {k! (n-k)}} $$

  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)

Function: beta_incomplete_regularized (a, b, z)

  The regularized incomplete beta function (DLMF 8.17.E2 and A&S eqn 6.6.2), defined as

  $$ I_z(a,b) = {{\rm B}_z(a,b)\over {\rm B}(a,b)} $$

  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

Function: beta_incomplete_generalized (a, b, z1, z2)

  The basic definition of the generalized incomplete beta function is

  $$ \int_{z_1}^{z_2} t^{a-1}(1-t)^{b-1}\; dt $$

  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)

Option variable: beta_expand

  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.

Option variable: beta_args_sum_to_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.

  See beta for examples.

Function: psi [n](x)

  `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 $$ \psi^{(n)}(x) = {d^{n+1}\over{dx^{n+1}}} \log\Gamma(x) $$

  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

Option variable: maxpsiposint

  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

Option variable: maxpsinegint

  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

Option variable: maxpsifracnum

  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

Option variable: maxpsifracdenom

  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

Function: makefact (expr)

  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)!

Function: numfactor (expr)

  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]