[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

15. Funciones Especiales


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

15.1 Introducción a las funciones especiales

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()                   Función Gamma
gammagreek(a,z)           Función Gamma incompleta
gammaincomplete(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

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

15.2 Funciones de Bessel

Función: bessel_j (v, z)

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: bessel_y (v, z)

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: bessel_i (v, z)

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: bessel_k (v, z)

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: hankel_1 (v, z)

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: hankel_2 (v, z)

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.

Variable optativa: besselexpand

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)
Función: scaled_bessel_i (v, z)

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

Función: scaled_bessel_i0 (z)

Idéntica a scaled_bessel_i(0,z).

Función: scaled_bessel_i1 (z)

Idéntica a scaled_bessel_i(1,z).

Función: %s [u,v] (z)

Función s[u,v](z) de Lommel. Gradshteyn & Ryzhik 8.570.1.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

15.3 Funciones de Airy

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: airy_ai (x)

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.

Función: airy_dai (x)

Es la derivada de la función Ai de Airy, airy_ai(x).

Véase airy_ai.

Función: airy_bi (x)

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.

Función: airy_dbi (x)

Es la derivada de la función Bi de Airy, airy_bi(x).

Véanse airy_ai y airy_bi.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

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 (a,z)

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

                              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: 1000000

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

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

15.5 Integral exponencial

La integral exponencial y sus funciones relacionadas se definen en el capítulo 5 de Abramowitz y Stegun, Handbook of Mathematical Functions.

Función: expintegral_e1 (z)

La integral exponencial E1(z) (A&S 5.1.1)

Función: expintegral_ei (z)

La integral exponencial Ei(z) (A&S 5.1.2)

Función: expintegral_li (z)

La integral exponencial Li(z) (A&S 5.1.3)

Función: expintegral_e (n,z)

La integral exponencial En(z) (A&S 5.1.4)

Función: expintegral_si (z)

La integral exponencial Si(z) (A&S 5.2.1)

Función: expintegral_ci (z)

La integral exponencial Ci(z) (A&S 5.2.2)

Función: expintegral_shi (z)

La integral exponencial Shi(z) (A&S 5.2.3)

Función: expintegral_chi (z)

La integral exponencial Chi(z) (A&S 5.2.4)

Option variable: expintrep

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.

Option variable: expintexpand

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 .


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

15.6 Función de error

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: erf (z)

Función de error erf(z) (A&S 7.1.1)

Véase también erfflag.

Función: erfc (z)

Complemento de la función de error erfc(z) (A&S 7.1.2)

erfc(z) = 1-erf(z)

Función: erfi (z)

Función de error imaginaria.

erfi(z) = -%i*erf(%i*z)

Función: erf_generalized (z1,z2)

Función de error generalizada Erf(z1,z2)

Función: fresnel_c (z)

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_c(%i*x) = %i*fresnel_c(x) se aplica cuando la variable global %iargs vale true.

Véanse también erf_representation y hypergeometric_representation.

Función: fresnel_s (z)

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.

Variable opcional: erf_representation

Valor por defecto: false

Cuando valga true erfc, erfi, erf_generalized, fresnel_s y fresnel_c se transforman a erf.

Variable opcional: hypergeometric_representation

Valor por defecto: false

Permite obtener la representación hipergeométrica de las funciones fresnel_s y fresnel_c.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

15.7 Funciones de Struve

Las funciones de Struve se definen en el capítulo 12 de Abramowitz y Stegun, Handbook of Mathematical Functions.

Función: struve_h (v, z)

Función H de Struve de orden v y argumento z, (A&S 12.1.1).

Función: struve_l (v, z)

Función L modificada de Struve de orden v y argumento z, (A&S 12.2.1).


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

15.8 Funciones hipergeométricas

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 [k,u] (z)

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 [k,u] (z)

Función W de Whittaker. (A&S 13.1.33)

Función: %f [p,q] ([a],[b],z)

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.

Función: hypergeometric ([a1, ..., ap],[b1, ... ,bq], x)

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

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

15.9 Funciones de cilindro parabólico

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: parabolic_cylinder_d (v, z)

Función de cilindro parabólico parabolic_cylinder_d(v,z). (A&s 19.3.1)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

15.10 Funciones y variables para las funciones especiales

Función: specint (exp(- s*t) * expr, t)

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
Función: hgfred (a, b, t)

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

Función: lambert_w (z)

Rama principal de la función W de Lambert, solución de la ecuación z = W(z) * exp(W(z)). (DLMF 4.13)

Función: generalized_lambert_w (k, z)

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: nzeta (z)

Función de dispersión del plasma. nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z))

Función: nzetar (z)

Devuelve realpart(nzeta(z)).

Función: nzetai (z)

Devuelve imagpart(nzeta(z)).


[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Robert on agosto, 12 2012 using texi2html 1.76.