Siguiente: Integral exponencial, Anterior: Funciones de Airy, Subir: Funciones Especiales [Índice general][Índice]
Las funciones gamma, beta, psi y gamma incompleta están definidas en el capítulo 6 de Abramowitz y Stegun, Handbook of Mathematical Functions.
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.
Valor por defecto: 10^8
El valor de algepsilon es usado por algsys.
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.
Calcula el factorial de números complejos de punto flotante grandes.
La instrucción load ("bffac") carga esta función.
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.
Logaritmo natural de la función gamma.
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 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 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 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.
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
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.
Transforma las funciones binomial, factorial y beta que aparecen en expr en funciones gamma.
Véase también makefact.
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
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 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
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)
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.
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.
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.
Valor por defecto: 20
La variable maxpsiposint guarda el mayor valor positivo para el
que psi[n](x) intentará calcular un valor exacto.
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.
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.
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.
Transforma las funciones binomial, gamma y beta que aparecen en expr en su notación factorial.
Véase también makegamma.
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]