Funciones Gamma y factorial (Manual de Maxima 5.46.0)

Siguiente: Integral exponencial, Anterior: Funciones de Airy, Subir: Funciones Especiales [Índice general][Índice]

### 15.4 Funciones Gamma y factorial

Las funciones gamma, beta, psi y gamma incompleta están definidas en el capítulo 6 de Abramowitz y Stegun, Handbook of Mathematical Functions.

Función: bffac (expr, n) ¶

  Versión para "bigfloat" de la función factorial (Gamma desplazada). El segundo argumento indica cuántos dígitos se conservan y devuelven, pudiendo utilizarse para obtener algunas cifras extra.

Variable optativa: algepsilon ¶

  Valor por defecto: 10^8

  El valor de `algepsilon` es usado por `algsys`.

Función: bfpsi (n, z, fpprec) ¶
Función: bfpsi0 (z, fpprec) ¶

  La función `bfpsi` es la poligamma de argumento real z y de orden el entero n. La función `bfpsi0` es la digamma. La llamada `bfpsi0 (z, fpprec)` equivale a `bfpsi (0, z, fpprec)`.

  Estas funciones devuelven valores "bigfloat". La variable fpprec es la precisión "bigfloat" del valor de retorno.

Función: cbffac (z, fpprec) ¶

  Calcula el factorial de números complejos de punto flotante grandes.

  La instrucción `load ("bffac")` carga esta función.

Función: gamma (x) ¶

  La definición básica de la función gamma (A&S 6.1.1) es

                                     inf
                                    /
                                    [     z - 1   - t
                         gamma(z) = I    t      %e    dt
                                    ]
                                    /
                                     0

  Maxima simplifica `gamma` para enteros positivos y para fracciones positivas o negativas. Para fracciones de denominador dos, el resultado es un número racional multiplicado por `sqrt(%pi)`. La simplificación para valores enteros la controla `factlim`. Para enteros mayores que `factlim` el resultado numérico de la función factorial, la cual se utiliza para calcular `gamma`, producirá un desbordamiento. La simplificación para números racionales la controla `gammalim` para evitar desbordamientos. Véanse también `factlim` y `gammalim`.

  Para enteros negativos, `gamma` no está definida.

  Maxima puede evaluar `gamma` numéricamente para valores reales y complejos, tanto en formato float (doble precisión) como big float (precisión arbitraria).

  La función `gamma` tiene simetría especular.

  Si `gamma_expand` vale `true`, Maxima expande `gamma` para argumentos del tipo `z+n` y `z-n`, siendo `n` un entero.

  Maxima conoce la derivada de `gamma`.

  Ejemplos:

  Simplificación para enteros, fracciones de denominador dos y números racionales:

      (%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

  Evaluación numérica para valores reales y complejos:

      (%i4) map('gamma,[2.5,2.5b0]);
      (%o4)             [1.329340388179137, 1.329340388179137b0]

      (%i5) map('gamma,[1.0+%i,1.0b0+%i]);
      (%o5) [.4980156681183558 - .1549498283018108 %i,
                            4.980156681183561b-1 - 1.549498283018107b-1 %i]

  Simetría especular:

      (%i6) declare(z,complex)$
      (%i7) conjugate(gamma(z));
      (%o7)                         gamma(conjugate(z))

  Maxima expande `gamma(z+n)` y `gamma(z-n)` si `gamma_expand` vale `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

  Derivada de `gamma`:

      (%i10) diff(gamma(z),z);
      (%o10)                         psi (z) gamma(z)
                                        0

  Véase también `makegamma`.

  La constante de Euler-Mascheroni es `%gamma`.

Función: log_gamma (z) ¶

  Logaritmo natural de la función gamma.

Función: gamma_incomplete_lower (a, z) ¶

  Función gamma incompleta inferior (A&S 6.5.2):

                                          z
                                         /
                                         [  a - 1   - t
          gamma_incomplete_lower(a, z) = I t      %e    dt
                                         ]
                                         /
                                          0

  Véase también `gamma_incomplete` (función gamma incompleta superior).

Función: gamma_incomplete (a,z) ¶

  Función gamma incompleta superior, A&S 6.5.3:

                                    inf
                                   /
                                   [     a - 1   - t
          gamma_incomplete(a, z) = I    t      %e    dt
                                   ]
                                   /
                                    z

  Véanse también `gamma_expand` para controlar cómo se expresa `gamma_incomplete` en términos de funciones elementales y de `erfc`.

  Véanse también las funciones relacionadas `gamma_incomplete_regularized` y `gamma_incomplete_generalized`.

Función: gamma_incomplete_regularized (a,z) ¶

  Función gamma incompleta superior regularizada, A&S 6.5.1.

      gamma_incomplete_regularized(a, z) =
                                              gamma_incomplete(a, z)
                                              ----------------------
                                                     gamma(a)

  Véanse también `gamma_expand` para controlar cómo se expresa `gamma_incomplete` en términos de funciones elementales y de `erfc`.

  Véase también `gamma_incomplete`.

Función: gamma_incomplete_generalized (a,z1,z1) ¶

  Función gamma incompleta generalizada.

      gamma_incomplete_generalized(a, z1, z2) =
                                                     z2
                                                    /
                                                    [    a - 1   - t
                                                    I   t      %e    dt
                                                    ]
                                                    /
                                                     z1

  Véanse también `gamma_incomplete` y `gamma_incomplete_regularized`.

Variable opcional: gamma_expand ¶

  Valor por defecto: `false`

  `gamma_expand` controla la expansión de `gamma_incomplete`. Si `gamma_expand` vale `true`, `gamma_incomplete(v,z)` se expande en términos de `z`, `exp(z)` y `erfc(z)`, siempre que sea posible.

      (%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

Variable optativa: gammalim ¶

  Valor por defecto: 10000

  La variable `gammalim` controla la simplificación de la función gamma con argumentos enteros o racionales. Si el valor absoluto del argumento no es mayor que `gammalim`, entonces se realizará la simplificación. Nótese que la variable `factlim` también controla la simplificación del resultado de `gamma` con argumento entero.

Función: makegamma (expr) ¶

  Transforma las funciones `binomial`, `factorial` y `beta` que aparecen en expr en funciones `gamma`.

  Véase también `makefact`.

Función: beta (a, b) ¶

  La función beta se define como `gamma(a) gamma(b)/gamma(a+b)` (A&S 6.2.1).

  Maxima simplifica la función beta para enteros positivos y números racionales cuya suma sea entera. Si `beta_args_sum_to_integer` vale `true`, Maxima también simplifica expresiones generales cuya suma sea también entera.

  Cuando a o b sean nulos, la función beta no está definida.

  En general, la función beta no está definida para enteros negativos. La excepción es para a=-n, siendo n un entero positivo y b otro entero positivo tal que b<=n, entonces es posible definir una continuación analítica. En este caso Maxima devuelve un resultado.

  Si `beta_expand` vale `true`, expresiones como `beta(a+n,b)`, `beta(a-n,b)`, `beta(a,b+n)` o `beta(a,b-n)`, siendo `n` entero, se simplifican.

  Maxima puede evaluar la función beta para valores reales y complejos, tanto de tipo decimal flotante o big float. Para la evaluación numérica Maxima utiliza `log_gamma`:

                 - log_gamma(b + a) + log_gamma(b) + log_gamma(a)
               %e

  Maxima reconoce la simetría de la función beta.

  Maxima conoce las derivadas de la función beta, tanto respecto de a como de b.

  Para expresar la función beta como un cociente de funciones gamma, véase `makegamma`.

  Ejemplos:

  Simplificación cuando uno de sus argumentos es entero:

      (%i1) [beta(2,3),beta(2,1/3),beta(2,a)];
                                     1   9      1
      (%o1)                         [--, -, ---------]
                                     12  4  a (a + 1)

  Simplificación para argumentos racionales que suman un entero:

      (%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)

  Cuando se iguala `beta_args_sum_to_integer` a `true` se simplifican expresiones más generales si la suma de los argumentos se reduce a un entero:

      (%i3) beta_args_sum_to_integer:true$
      (%i4) beta(a+1,-a+2);
                                      %pi (a - 1) a
      (%o4)                         ------------------
                                    2 sin(%pi (2 - a))

  Posibles valores cuando uno de los argumentos es entero negativo:

      (%i5) [beta(-3,1),beta(-3,2),beta(-3,3)];
                                          1  1    1
      (%o5)                            [- -, -, - -]
                                          3  6    3

  `beta(a+n,b)` o `beta(a-n)` con `n` entero se simplifica si `beta_expand` vale `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

  La función beta no está definida si uno de sus argumentos es cero:

      (%i7) beta(0,b);
      beta: expected nonzero arguments; found 0, b
       -- an error.  To debug this try debugmode(true);

  Evaluación numérica para argumentos reales y complejos de tipo decimal flotante o big float:

      (%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

  La función beta es simétrica con simetría especular:

      (%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))

  Derivada de la función beta respecto de `a`:

      (%i17) diff(beta(a,b),a);
      (%o17)               - beta(a, b) (psi (b + a) - psi (a))
                                            0             0

Función: beta_incomplete (a, b, z) ¶

  La definición básica de la función beta incompleta (A&S 6.6.1) es

                             z
                            /
                            [         b - 1  a - 1
                            I  (1 - t)      t      dt
                            ]
                            /
                             0

  Esta definición es posible para realpart(a)>0, realpart(b)>0 y abs(z)<1. Para otras situaciones, la función beta incompleta puede definirse por medio de una función hipergeométrica generalizada:

         gamma(a) hypergeometric_generalized([a, 1 - b], [a + 1], z) z

  (Véase Funcións.wolfram.com para una completa definición de la función beta incompleta.)

  Para enteros negativos a = -n y enteros positivos b=m con m<=n la función beta incompleta se define como

                                  m - 1           k
                                  ====  (1 - m)  z
                            n - 1 \            k
                           z       >    -----------
                                  /     k! (n - k)
                                  ====
                                  k = 0

  Maxima utiliza esta definición para simplificar `beta_incomplete` cuando a es entero negativo.

  Cuando a es entero positivo, `beta_incomplete` se simplifica para cualesquiera argumentos b y z, y para b entero positivo para cualesquiera argumentos a y z, con la excepción de cuando a sea entero negativo.

  Para z=0 y realpart(a)>0, `beta_incomplete` se anula. Para z=1 y realpart(b)>0, `beta_incomplete` se reduce a la función `beta(a,b)`.

  Maxima evalúa `beta_incomplete` numéricamente para valores reales y complejos en forma decimal y big float. La evaluación numérica se realiza expandiendo la función beta incompleta en fracciones continuas.

  Si `beta_expand` vale `true`, Maxima expande las expresiones `beta_incomplete(a+n,b,z)` y `beta_incomplete(a-n,b,z)`, siendo n entero positivo.

  Maxima conoce las derivadas de `beta_incomplete` con respecto a las variables a, b y z, así como la integral respecto de la variable z.

  Ejemplos:

  Simplificación para a entero positivo:

      (%i1) beta_incomplete(2,b,z);
                                             b
                                  1 - (1 - z)  (b z + 1)
      (%o1)                       ----------------------
                                        b (b + 1)

  Simplificación para b entero positivo:

      (%i2) beta_incomplete(a,2,z);
                                                     a
                                    (a (1 - z) + 1) z
      (%o2)                         ------------------
                                        a (a + 1)

  Simplificación para a y b enteros positivos:

      (%i3) beta_incomplete(3,2,z);
                                                     3
                                    (3 (1 - z) + 1) z
      (%o3)                         ------------------
                                            12

  Para a entero negativo y b<=(-a):

      (%i4) beta_incomplete(-3,1,z);
                                             1
      (%o4)                              - ----
                                              3
                                           3 z

  Simplificación para los valores z=0 y z=1:

      (%i5) assume(a>0,b>0)$
      (%i6) beta_incomplete(a,b,0);
      (%o6)                                 0
      (%i7) beta_incomplete(a,b,1);
      (%o7)                            beta(a, b)

  Evaluación numérica, tanto con float (precisión doble) como big float (precisión arbitraria):

      (%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

  Para abs(z)>1, `beta_incomplete` devuelve un resultado complejo:

      (%i11) beta_incomplete(0.25,0.50,1.7);
      (%o11)              5.244115108584249 - 1.45518047787844 %i

  Resultados para argumentos complejos más generales:

      (%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)

  Expansión cuando `beta_expand` vale `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

  Derivada e integral de `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)

Función: beta_incomplete_regularized (a, b, z) ¶

  Función beta incompleta regularizada A&S 6.6.2, definida como

      beta_incomplete_regularized(a, b, z) =
                                            beta_incomplete(a, b, z)
                                            ------------------------
                                                   beta(a, b)

  Al igual que `beta_incomplete`, esta definición no es completa. Véase Funcións.wolfram.com para una definición completa de `beta_incomplete_regularized`.

  `beta_incomplete_regularized` se simplifica para a o b entero positivo.

  Para z=0 y realpart(a)>0, `beta_incomplete_regularized` se anula. Para z=1 y realpart(b)>0, `beta_incomplete_regularized` se reduce a 1.

  Maxima evalúa `beta_incomplete_regularized` numéricamente para valores reales y complejos en forma decimal y big float.

  Si `beta_expand` vale `true`, Maxima expande `beta_incomplete_regularized` para los argumentos a+n o a-n, siendo n entero.

  Maxima conoce las derivadas de `beta_incomplete_regularized` con respecto a las variables a, b y z, así como la integral respecto de la variable z.

  Ejemplos:

  Simplificación para a o b enteros positivos:

      (%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

  Simplificación para los valores z=0 y z=1:

      (%i4) assume(a>0,b>0)$
      (%i5) beta_incomplete_regularized(a,b,0);
      (%o5)                                 0
      (%i6) beta_incomplete_regularized(a,b,1);
      (%o6)                                 1

  Evaluación numérica, tanto con float (precisión doble) como big float (precisión arbitraria):

      (%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

  Expansión cuando `beta_expand` vale `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)

  Derivada e integral respecto de 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

Función: beta_incomplete_generalized (a, b, z1, z2) ¶

  La definición básica de la función beta incompleta generalizada es

  The basic definition of the generalized incomplete beta function is

                            z2
                           /
                           [          b - 1  a - 1
                           I   (1 - t)      t      dt
                           ]
                           /
                            z1

  Maxima simplifica `beta_incomplete_regularized` para a y b enteros positivos.

  Para realpart(a)>0 y z1=0 o z2=0, Maxima reduce `beta_incomplete_generalized` a `beta_incomplete`. Para realpart(b)>0 y z1=1 o z2=1, Maxima reduce a una expresión con `beta` y `beta_incomplete`.

  Maxima evalúa `beta_incomplete_generalized` numéricamente para valores reales y complejos en forma decimal y big float.

  Si `beta_expand` vale `true`, Maxima expande `beta_incomplete_generalized` para los argumentos a+n y a-n, siendo n entero positivo.

  Maxima conoce las derivadas de `beta_incomplete_generalized` con respecto a las variables a, b, z1 y z2, así como la integral respecto de las variables z1 y z2.

  Ejemplos:

  Maxima simplifica `beta_incomplete_generalized` para a y b enteros positivos:

      (%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

  Simplificación para los valores z1=0, z2=0, z1=1 o 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)

  Evaluación numérica para argumentos reales, tanto con float (precisión doble) como big float (precisión arbitraria):

      (%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

  Evaluación numérica para argumentos complejos, tanto con float (precisión doble) como big float (precisión arbitraria):

      (%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

  Expansión para a+n o a-n, siendo n entero positivo con `beta_expand` igual `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

  Derivada respecto de la variable z1 e integrales respecto de z1 y 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)

Variable opcional: beta_expand ¶

  Valor por defecto: false

  Si `beta_expand` vale `true`, `beta(a,b)` y sus funciones relacionadas se expanden para argumentos del tipo a+n o a-n, siendo n un número entero.

Variable opcional: beta_args_sum_to_integer ¶

  Valor por defecto: false

  Si `beta_args_sum_to_integer` vale `true`, Maxima simplifica `beta(a,b)` cuando la suma de los argumentos a y b sea un entero.

Función: psi [n](x) ¶

  Es la derivada de `log (gamma (x))` de orden `n+1`, de tal manera que `psi[0](x)` es la primera derivada, `psi[1](x)` la segunda derivada y así sucesivamente.

  En general, Maxima no sabe cómo calcular valores numéricos de `psi`, pero sí conoce el valor exacto para algunos argumentos racionales. Existen algunas variables globales para controlar en qué rangos racionales debe devolver `psi` resultados exactos, si ello es posible. Véanse las descripciones de `maxpsiposint`, `maxpsinegint`, `maxpsifracnum` y `maxpsifracdenom`. En resumen, x debe alcanzar un valor entre `maxpsinegint` y `maxpsiposint`. Si el valor absoluto de la parte fraccional de x es racional y tiene un numerador menor que `maxpsifracnum` y un denominador menor que `maxpsifracdenom`, la función `psi` devolverá un valor exacto.

  La función `bfpsi` del paquete `bffac` puede calcular valores numéricos.

Variable opcional: maxpsiposint ¶

  Valor por defecto: 20

  La variable `maxpsiposint` guarda el mayor valor positivo para el que `psi[n](x)` intentará calcular un valor exacto.

Variable opcional: maxpsinegint ¶

  Valor por defecto: -10

  La variable `maxpsinegint` guarda el menor valor negativo para el que `psi[n](x)` intentará calcular un valor exacto. Si x es menor que `maxnegint`, `psi[n](x)` no devolverá una respuesta simplificada, aunque supiese cómo hacerlo.

Variable opcional: maxpsifracnum ¶

  Valor por defecto: 6

  Sea x un número racional menor que la unidad de la forma `p/q`. Si `p` es mayor que `maxpsifracnum`, entonces `psi[n](x)` no devolverá una respuesta simplificada.

Variable opcional: maxpsifracdenom ¶

  Valor por defecto: 6

  Sea x un número racional menor que la unidad de la forma `p/q`. Si `q` es mayor que `maxpsifracnum`, entonces `psi[n](x)` no devolverá una respuesta simplificada.

Función: makefact (expr) ¶

  Transforma las funciones `binomial`, `gamma` y `beta` que aparecen en expr en su notación factorial.

  Véase también `makegamma`.

Función: numfactor (expr) ¶

  Devuelve el factor numérico que multiplica a la expresión expr, la cual debe tener un único término.

      (%i1) gamma (7/2);
                                15 sqrt(%pi)
      (%o1)                     ------------
                                     8
      (%i2) numfactor (%);
                                     15
      (%o2)                          --
                                     8

Siguiente: Integral exponencial, Anterior: Funciones de Airy, Subir: Funciones Especiales [Índice general][Índice]