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
     %he[n] (z)                Polinomio de Hermite (Ojo: he, no h.
                                       Ver A&S 22.5.18)
     %p[u,v] (z)               Función de Legendre de primera especie
     %q[u,v] (z)               Función de Legendre de segunda especie
     hstruve[n] (z)            Función H de Struve
     lstruve[n] (z)            Función L de Struve
     %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
     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
     ei (z)                    Integral exponencial (?)
     kelliptic (z)             Integral elíptica completa
                                       de primera especie (K)
     %d [n] (z)                Función cilíndrica parabólica

Funciones y variables para las funciones especiales
===================================================

 -- Función: airy_ai (X)
     Función Ai de Airy, tal como la definen Abramowitz y Stegun, Handbook of Mathematical Functions, Sección 10.4.

     La ecuación de Airy diff (y(x), x, 2) - x y(x) = 0 tiene dos soluciones linealmente independientes, y = Ai(x) y y = Bi(x). La derivada diff (airy_ai(x), x) es airy_dai(x).

     Si el argumento x es un número decimal real o complejo, se devolverá el valor numérico de airy_ai siempre que sea posible.

     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.

 -- Función: asympa
     El paquete asympa contiene funciones de simplificación para realizar análisis asintótico, incluyendo las funciones  ``big O'' y  ``little o'', de uso frecuente en el análisis complejo y numérico.

     La instrucción load ("asympa") carga este paquete.

 -- Función: bessel (Z, A)
     Función de Bessel de primera especie.

     Ya no se recomienda su uso.  Utilícese bessel_j (Z, A) en su lugar.

 -- Función: bessel_j (V, Z)
     Función de Bessel de primera especie de orden v y argumento z.

     La función bessel_j calcula el arreglo besselarray tal que besselarray [i] = bessel_j [i + v - int(v)] (z) para i desde cero hasta int(v).

     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 calcula el arreglo besselarray tal que besselarray [i] = bessel_y [i + v - int(v)] (z) para i desde cero hasta int(v).

     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 calcula el arreglo besselarray tal que besselarray [i] = bessel_i [i + v - int(v)] (z) para i desde cero hasta int(v).

     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 calcula el arreglo besselarray tal que besselarray [i] = bessel_k [i + v - int(v)] (z) para i desde cero hasta int(v).

     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.

 -- 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);
                                    2 z   sin(z)   cos(z)
          (%o4)                sqrt(---) (------ - ------)
                                    %pi      2       z
                                            z

 -- 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: beta (X, Y)
     Función beta, definida como gamma(x) gamma(y)/gamma(x + y).

 -- Función: gamma (X)
     Función gamma.

     Véase también makegamma.

     La variable gammalim controla la simplificación de la función gamma.

     La constante de Euler-Mascheroni es %gamma.

 -- 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: intopois (A)
     Convierte A en un codificado Poisson.

 -- 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: makegamma (EXPR)
     Transforma las funciones binomial, factorial y beta que aparecen en EXPR en funciones gamma.

     Véase también makefact.

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

 -- Función: outofpois (A)
     Convierte A desde codificado de Poisson a una representación general.  Si A no está en forma de Poisson, outofpois hace la conversión, siendo entonces el valor retornado outofpois (intopois (A)). Esta función es un simplificador canónico para sumas de potencias de senos y cosenos.

 -- Función: poisdiff (A, B)
     Deriva A con respecto a B. El argumento B debe aparecer sólo en los argumentos trigonométricos o sólo en los coeficientes.

 -- Función: poisexpt (A, B)
     Idéntico a intopois (A^B). El argumento B debe ser un entero positivo.

 -- Variable optativa: poislim
     Valor por defecto: 5

     La variable poislim determina el dominio de los coeficientes en los argumentos de las funciones trigonométricas.  El valor por defecto 5 corresponde al intervalo [-2^(5-1)+1,2^(5-1)], o [-15,16], pero puede reasignarse para  [-2^(n-1)+1, 2^(n-1)].

 -- Función: poisplus (A, B)
     Idéntico a intopois (a + b).

 -- Función: poissimp (A)
     Convierte A en una serie de Poisson para A en su representación general.

 -- Símbolo especial: poisson
     El símbolo /P/ sigue a la etiqueta de las líneas que contienen expresiones que son series de Poisson.

 -- Función: poissubst (A, B, C)
     Sustituye B por A en C, donde  C es una serie de Poisson.

     (1) Si B es una de las variables U, V, W, X, Y o Z, entonces A debe ser una expresión lineal en esas variables (por ejemplo, 6*u + 4*v).

     (2) Si B no es ninguna de esas variables, entonces A no puede contener tampoco a ninguna de ellas, ni senos, ni cosenos.

 -- Función: poistimes (A, B)
     Idéntico a intopois (A*B).

 -- Función: printpois (A)
     Presenta una serie de Poisson en un formato legible.  Conjuntamente con outofpois, si es necesario convertirá A primero en una codificación de Poisson.

 -- 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 maxpsifracnum. 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: 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.

     Si specint no puede calcular la integral, le valor devuelto puede contener símbolos de Lisp, incluyendo other-defint-to-follow-negtest, other-lt-exponential-to-follow, product-of-y-with-nofract-indices, etc.; se trata de un fallo pendiente de corrección.

     La ejecución de demo(hypgeo) muestra algunso ejemplos de transformadas de Laplace calculadas con specint.

     Examples:

          (%i1) assume (p > 0, a > 0);
          (%o1)                    [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