Siguiente: Funciones elípticas, Anterior: Polinomios [Índice general][Índice]
Siguiente: Funciones de Bessel, Anterior: Funciones Especiales, Subir: Funciones Especiales [Índice general][Índice]
A continuación se especifican las notaciones correspondientes a las funciones especiales:
bessel_j (index, expr) Función de Bessel de primera especie
bessel_y (index, expr) Función de Bessel de segunda especie
bessel_i (index, expr) Función de Bessel modificada de primera especie
bessel_k (index, expr) Función de Bessel modificada de segunda especie
hankel_1 (v,z) Función de Hankel de primera especie
hankel_2 (v,z) Función de Hankel de segunda especie
struve_h (v,z) Función H de Struve
struve_l (v,z) Función L de Struve
%p[u,v] (z) Función de Legendre de primera especie
%q[u,v] (z) Función de Legendre de segunda especie
%f[p,q] ([], [], expr) Función hipergeométrica generalizada
gamma(z) Función Gamma
gamma_incomplete_lower(a,z) Función Gamma incompleta inferior
gamma_incomplete (a,z) Extremo de la función Gamma incompleta
hypergeometric(l1, l2, z) Función hipergeométrica
slommel
%m[u,k] (z) Función de Whittaker de primera especie
%w[u,k] (z) Función de Whittaker de segunda especie
erfc (z) Complemento de la función de error, erf
expintegral_e (v,z) Integral exponencial E
expintegral_e1 (z) Integral exponencial E1
expintegral_ei (z) Integral exponencial Ei
expintegral_li (z) Integral logarítmica Li
expintegral_si (z) Integral exponencial Si
expintegral_ci (z) Integral exponencial Ci
expintegral_shi (z) Integral exponencial Shi
expintegral_chi (z) Integral exponencial Chi
kelliptic (z) Integral elíptica completa
de primera especie (K)
parabolic_cylinder_d(v,z) Función D de cilindro parabólico
Siguiente: Funciones de Airy, Anterior: Introducción a las funciones especiales, Subir: Funciones Especiales [Índice general][Índice]
Función de Bessel de primera especie de orden v y argumento z.
La función bessel_j se define como
inf
==== k - v - 2 k v + 2 k
\ (- 1) 2 z
> --------------------------
/ k! gamma(v + k + 1)
====
k = 0
aunque la serie infinita no se utiliza en los cálculos.
Función de Bessel de segunda especie de orden v y argumento z.
La función bessel_y se define como
cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
-------------------------------------------
sin(%pi v)
si v no es un entero. En caso de que v sea un entero n, se calcula el límite cuando v se aproxima a n.
Función modificada de Bessel de primera especie de orden v y argumento z.
La función bessel_i se define como
inf
==== - v - 2 k v + 2 k
\ 2 z
> -------------------
/ k! gamma(v + k + 1)
====
k = 0
aunque la serie infinita no se utiliza en los cálculos.
Función modificada de Bessel de segunda especie de orden v y argumento z.
La función bessel_k se define como
%pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
-------------------------------------------------
2
si v no es un entero. Si v es igual al entero n, entonces se calcula el límite cuando v tiende a n.
Función de Hankel de primera especie de orden v y argumento z
(A&S 9.1.3). La función hankel_1 se define como
bessel_j(v,z) + %i * bessel_y(v,z)
Maxima evalúa hankel_1 numéricamente para el orden real v
y el argumento complejo z en doble precisión (float). La evaluación
numérica en gran precisión (bigfloat) y para órdenes complejos no está
implementada.
Si besselexpand vale true, hankel_1 se expande en
términos de funciones elementales cuando el orden v es la mitad
de un entero impar. Véase al respecto besselexpand.
Maxima reconoce la derivada de hankel_1 con respecto del argumento z.
Ejemplos:
Evaluación numérica:
(%i1) hankel_1(1,0.5); (%o1) .2422684576748738 - 1.471472392670243 %i (%i2) hankel_1(1,0.5+%i); (%o2) - .2558287994862166 %i - 0.239575601883016
No se soportan órdenes complejos. Maxima devuelve una forma nominal:
(%i3) hankel_1(%i,0.5+%i); (%o3) hankel_1(%i, %i + 0.5)
Expansión de hankel_1 cuando besselexpand vale true:
(%i4) hankel_1(1/2,z),besselexpand:true;
sqrt(2) sin(z) - sqrt(2) %i cos(z)
(%o4) ----------------------------------
sqrt(%pi) sqrt(z)
Derivada de hankel_1 respecto del argumento z. No está
soportada la derivada respecto del orden v. Maxima devuelve una forma nominal:
(%i5) diff(hankel_1(v,z),z);
hankel_1(v - 1, z) - hankel_1(v + 1, z)
(%o5) ---------------------------------------
2
(%i6) diff(hankel_1(v,z),v);
d
(%o6) -- (hankel_1(v, z))
dv
Función de Hankel de segunda especie de orden v y argumento z
(A&S 9.1.4). La función hankel_2 se define como
bessel_j(v,z) - %i * bessel_y(v,z)
Maxima evalúa hankel_2 numéricamente para el orden real v
y el argumento complejo z en doble precisión (float). La evaluación
numérica en gran precisión (bigfloat) y para órdenes complejos no está
implementada.
Si besselexpand vale true, hankel_2 se expande en
términos de funciones elementales cuando el orden v es la mitad
de un entero impar. Véase al respecto besselexpand.
Maxima reconoce la derivada de hankel_2 con respecto del argumento z.
Véanse ejemplos en hankel_1.
Valor por defecto: false
Controla la expansión de las funciones de Bessel cuando el orden es la mitad de un entero impar. En tal caso, las funciones de Bessel se pueden expandir en términos de otras funciones elementales. Si besselexpand vale true, se expande la función de Bessel.
(%i1) besselexpand: false$
(%i2) bessel_j (3/2, z);
3
(%o2) bessel_j(-, z)
2
(%i3) besselexpand: true$
(%i4) bessel_j (3/2, z);
sin(z) cos(z)
sqrt(2) sqrt(z) (------ - ------)
2 z
z
(%o4) ---------------------------------
sqrt(%pi)
Es la función de Bessel modificada de primera especie de
orden v y argumento z, es decir
scaled_bessel_i(v,z) = exp(-abs(z))*bessel_i(v, z).
Esta función es especialmente útil para calcular bessel_i
cuando z es grande. Sin embargo, Maxima no sabe mucho más
sobre esta función. En cálculos simbólicos, quizás sea
preferible trabajar directamente con la expresión
exp(-abs(z))*bessel_i(v, z).
Idéntica a scaled_bessel_i(0,z).
Idéntica a scaled_bessel_i(1,z).
Función s[u,v](z) de Lommel. Gradshteyn & Ryzhik 8.570.1.
Siguiente: Funciones Gamma y factorial, Anterior: Funciones de Bessel, Subir: Funciones Especiales [Índice general][Índice]
Las funciones de Airy Ai(x) y Bi(x) se definen en la sección 10.4. de Abramowitz and Stegun, Handbook of Mathematical Functions.
y = Ai(x) y y = Bi(x) son dos soluciones linealmente
independientes de la ecuación diferencia de Airy
diff (y(x), x, 2) - x y(x) = 0.
Si el argumento x es un número decimal en coma flotante
real o complejo, se devolverá el valor numérico de la función.
Función de Airy Ai(x). (A&S 10.4.2)
La derivada diff (airy_ai(x), x) es airy_dai(x).
Véanse airy_bi, airy_dai y airy_dbi.
Es la derivada de la función Ai de Airy, airy_ai(x).
Véase airy_ai.
Es la función Bi de Airy, tal como la definen Abramowitz y Stegun,
Handbook of Mathematical Functions, Sección 10.4. Se trata de la segunda solución de la ecuación de Airy diff (y(x), x, 2) - x y(x) = 0.
Si el argumento x es un número decimal real o complejo, se devolverá el valor numérico de airy_bi siempre que sea posible. En los otros casos, se devuelve la expresión sin evaluar.
La derivada diff (airy_bi(x), x) es airy_dbi(x).
Véanse airy_ai y airy_dbi.
Es la derivada de la función Bi de Airy, airy_bi(x).
Véanse airy_ai y airy_bi.
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: Función de error, Anterior: Funciones Gamma y factorial, Subir: Funciones Especiales [Índice general][Índice]
La integral exponencial y sus funciones relacionadas se definen en el capítulo 5 de Abramowitz y Stegun, Handbook of Mathematical Functions.
La integral exponencial E1(z) (A&S 5.1.1)
La integral exponencial Ei(z) (A&S 5.1.2)
La integral exponencial Li(z) (A&S 5.1.3)
La integral exponencial En(z) (A&S 5.1.4)
La integral exponencial Si(z) (A&S 5.2.1)
La integral exponencial Ci(z) (A&S 5.2.2)
La integral exponencial Shi(z) (A&S 5.2.3)
La integral exponencial Chi(z) (A&S 5.2.4)
Valor por defecto: false
Transforma la representación de la integral exponencial
en términos de las funciones gamma_incomplete,
expintegral_e1, expintegral_ei,
expintegral_li, expintegral_trig y expintegral_hyp.
Valor por defecto: false
Expande la integral exponencial E[n](z) para valores medios de la integral en términos de las funciones Erfc o Erf y para positivos enteros en términos de Ei .
Siguiente: Funciones de Struve, Anterior: Integral exponencial, Subir: Funciones Especiales [Índice general][Índice]
La función de error y sus asociadas se definen en el capítulo 7 de Abramowitz y Stegun, Handbook of Mathematical Functions.
Función de error erf(z) (A&S 7.1.1)
Véase también erfflag.
Complemento de la función de error erfc(z) (A&S 7.1.2)
erfc(z) = 1-erf(z)
Función de error imaginaria.
erfi(z) = -%i*erf(%i*z)
Función de error generalizada Erf(z1,z2)
Integral de Fresnel C(z) = integrate(cos((%pi/2)*t^2),t,0,z). (A&S 7.3.1)
La simplificación fresnel_c(-x) = -fresnel_c(x) se aplica cuando
la variable global trigsign vale true.
La simplificación fresnel_s(%i*x) = -%i*fresnel_s(x) se aplica cuando
la variable global %iargs vale true.
Véanse también erf_representation y
hypergeometric_representation.
Integral de Fresnel S(z) = integrate(sin((%pi/2)*t^2),t,0,z). (A&S 7.3.2)
La simplificación fresnel_s(-x) = -fresnel_s(x) se aplica cuando
la variable global trigsign vale true.
La simplificación fresnel_s(%i*x) = %i*fresnel_s(x) se aplica cuando
la variable global %iargs vale true.
Véanse también erf_representation y
hypergeometric_representation.
Valor por defecto: false
Cuando valga true erfc, erfi, erf_generalized, fresnel_s
y fresnel_c se transforman a erf.
Valor por defecto: false
Permite obtener la representación hipergeométrica de las funciones fresnel_s y fresnel_c.
Siguiente: Funciones hipergeométricas, Anterior: Función de error, Subir: Funciones Especiales [Índice general][Índice]
Las funciones de Struve se definen en el capítulo 12 de Abramowitz y Stegun, Handbook of Mathematical Functions.
Función H de Struve de orden v y argumento z, (A&S 12.1.1).
Función L modificada de Struve de orden v y argumento z, (A&S 12.2.1).
Siguiente: Funciones de cilindro parabólico, Anterior: Funciones de Struve, Subir: Funciones Especiales [Índice general][Índice]
Las funciones hipergeométricas se definen en los capítulos 13 y 15 de Abramowitz y Stegun, Handbook of Mathematical Functions.
Maxima tiene un soporte limitado sobre estas funciones, que pueden
aparecer en resultados devueltos por hgfred.
Función M de Whittaker
M[k,u](z) = exp(-z/2)*z^(1/2+u)*M(1/2+u-k,1+2*u,z).
(A&S 13.1.32)
Función W de Whittaker. (A&S 13.1.33)
Es la función hipergeométrica pFq(a1,a2,..ap;b1,b2,..bq;z),
donde a es una lista de longitud p y
b otra lista de longitud q.
Es la función hipergeométrica. A diferencia de la función
hipergeométrica %f de Maxima, la función hypergeometric
es simplificadora; además, hypergeometric soporta la evaluación
en doble (float) y gran (bigfloat) precisión. La evaluación
numérica fuera del círculo unidad no está en general
soportada, pero sí en el caso de la función
hipergeométrica de Gauss, cuando p = 2 y q = 1.
Si la variable opcional expand_hypergeometric vale true,
(el valor por defecto es false) y uno de los argumentos entr a1
y ap es entero negativo (caso polinomial), entonces hypergeometric
devuelve un polinomio expandido.
Ejemplos:
(%i1) hypergeometric([],[],x); (%o1) %e^x
Los polinomios se expanden automáticamente cuando expand_hypergeometric
vale true.
(%i2) hypergeometric([-3],[7],x); (%o2) hypergeometric([-3],[7],x) (%i3) hypergeometric([-3],[7],x), expand_hypergeometric : true; (%o3) -x^3/504+3*x^2/56-3*x/7+1
Se soporta la evaluación en doble (float) y gran (bigfloat) precisión:
(%i4) hypergeometric([5.1],[7.1 + %i],0.42);
(%o4) 1.346250786375334 - 0.0559061414208204 %i
(%i5) hypergeometric([5,6],[8], 5.7 - %i);
(%o5) .007375824009774946 - .001049813688578674 %i
(%i6) hypergeometric([5,6],[8], 5.7b0 - %i), fpprec : 30;
(%o6) 7.37582400977494674506442010824b-3
- 1.04981368857867315858055393376b-3 %i
Siguiente: Funciones y variables para las funciones especiales, Anterior: Funciones hipergeométricas, Subir: Funciones Especiales [Índice general][Índice]
Las funciones de cilindro parabólico se definen en el capítulo 19 de Abramowitz y Stegun, Handbook of Mathematical Functions.
Maxima tiene un soporte limitado sobre estas funciones, que pueden
aparecer en resultados devueltos por hgfred.
Función de cilindro parabólico parabolic_cylinder_d(v,z). (A&s 19.3.1)
Anterior: Funciones de cilindro parabólico, Subir: Funciones Especiales [Índice general][Índice]
Calcula la transformada de Laplace de expr respecto de la variable t. El integrando expr puede contener funciones especiales.
La función specint admite las funciones especiales siguientes:
la gamma incompleta, las funciones de error (pero no erfi, siendo
sencillo transformar erfi en la función de error erf),
integrales exponenciales, funciones de Bessel (incluidos productos de
funciones de Bessel), funciones de Hankel, de Hermite y los polinomios de
Laguerre.
Además, specint también admite la función hipergeométrica
%f[p,q]([],[],z), la función de Whittaker de primera especie
%m[u,k](z) y la de segunda especie %w[u,k](z).
El resultado puede darse en términos de funciones especiales y es posible que incluya también funciones hipergeométricas sin simplificar.
Cuando laplace es incapaz de calcular la transformada de Laplace,
entonces llama a la función specint. Puesto que laplace
tiene programadas más reglas para calcular transformadas de Laplace,
es preferible utilizar laplace en lugar de specint.
La ejecución de demo(hypgeo) muestra algunos ejemplos de
transformadas de Laplace calculadas con specint.
Ejemplos:
(%i1) assume (p > 0, a > 0)$
(%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
sqrt(%pi)
(%o2) ------------
a 3/2
2 (p + -)
4
(%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2))
* exp(-p*t), t);
- a/p
sqrt(a) %e
(%o3) ---------------
2
p
Ejemplos para integrales exponenciales:
(%i4) assume(s>0,a>0,s-a>0)$
(%i5) ratsimp(specint(%e^(a*t)
*(log(a)+expintegral_e1(a*t))*%e^(-s*t),t));
log(s)
(%o5) ------
s - a
(%i6) logarc:true$
(%i7) gamma_expand:true$
radcan(specint((cos(t)*expintegral_si(t)
-sin(t)*expintegral_ci(t))*%e^(-s*t),t));
log(s)
(%o8) ------
2
s + 1
ratsimp(specint((2*t*log(a)+2/a*sin(a*t)
-2*t*expintegral_ci(a*t))*%e^(-s*t),t));
2 2
log(s + a )
(%o9) ------------
2
s
Resultados cuando se utiliza la expansión de gamma_incomplete
y se cambia la representación de expintegral_e1:
(%i10) assume(s>0)$
(%i11) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
1
gamma_incomplete(-, k s)
2
(%o11) ------------------------
sqrt(%pi) sqrt(s)
(%i12) gamma_expand:true$
(%i13) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
erfc(sqrt(k) sqrt(s))
(%o13) ---------------------
sqrt(s)
(%i14) expintrep:expintegral_e1$
(%i15) ratsimp(specint(1/(t+a)^2*%e^(-s*t),t));
a s
a s %e expintegral_e1(a s) - 1
(%o15) - ---------------------------------
a
Simplifica la función hipergeométrica generalizada en términos de otras funciones más sencillas. a es una lista de parámetros del numerador y b lo es de parámetros del denominador.
En caso de que hgfred no pueda simplificar la función hipergeométrica
devolverá una expresión de la forma %f[p,q]([a], [b], x), siendo p
el número de elementos de a y q el de b. Esta es la
función hipergeométrica generalizada pFq.
(%i1) assume(not(equal(z,0)));
(%o1) [notequal(z, 0)]
(%i2) hgfred([v+1/2],[2*v+1],2*%i*z);
v/2 %i z
4 bessel_j(v, z) gamma(v + 1) %e
(%o2) ---------------------------------------
v
z
(%i3) hgfred([1,1],[2],z);
log(1 - z)
(%o3) - ----------
z
(%i4) hgfred([a,a+1/2],[3/2],z^2);
1 - 2 a 1 - 2 a
(z + 1) - (1 - z)
(%o4) -------------------------------
2 (1 - 2 a) z
Tal como muestra el siguiente ejemplo, puede ser de utilidad cargar
también el paquete orthopoly. Nótese que L es el
polinomio generalizado de Laguerre.
(%i5) load("orthopoly")$
(%i6) hgfred([-2],[a],z);
(a - 1)
2 L (z)
2
(%o6) -------------
a (a + 1)
(%i7) ev(%);
2
z 2 z
(%o7) --------- - --- + 1
a (a + 1) a
Rama principal de la función W de Lambert, solución de
la ecuación z = W(z) * exp(W(z)). (DLMF 4.13)
k-ésima rama de la función W de Lambert’s, W(z), solución de
z = W(z) * exp(W(z)). (DLMF 4.13)
La rama principal, representada por Wp(z) en DLMF, es lambert_w(z) = generalized_lambert_w(0,z).
La otra rama con valores reales, representada por Wm(z) en DLMF, es generalized_lambert_w(-1,z).
Función de dispersión del plasma.
nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z))
Devuelve realpart(nzeta(z)).
Devuelve imagpart(nzeta(z)).
Siguiente: Funciones elípticas, Anterior: Polinomios [Índice general][Índice]