[ < ] | [ > ] |  | [ << ] | [ 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(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

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

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

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

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

Función: gamma_incomplete (a,z)

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

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

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

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

Función: gamma_incomplete_regularized (a,z)

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

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

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

  Véase también `gamma_incomplete`.

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

  Función gamma incompleta generalizada.

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

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

Variable opcional: gamma_expand

  Valor por defecto: `false`

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

      (%i1) gamma_incomplete(2,z);
      (%o1)                       gamma_incomplete(2, z)
      (%i2) gamma_expand:true;
      (%o2)                                true
      (%i3) gamma_incomplete(2,z);
                                                 - z
      (%o3)                            (z + 1) %e
      (%i4) gamma_incomplete(3/2,z);
                                    - z   sqrt(%pi) erfc(sqrt(z))
      (%o4)               sqrt(z) %e    + -----------------------
                                                     2

Variable optativa: gammalim

  Valor por defecto: 10000

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

Función: makegamma (expr)

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

  Véase también `makefact`.

Función: beta (a, b)

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

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

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

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

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

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

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

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

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

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

  Ejemplos:

  Simplificación cuando uno de sus argumentos es entero:

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

  Simplificación para argumentos racionales que suman un entero:

      (%i2) [beta(1/2,5/2),beta(1/3,2/3),beta(1/4,3/4)];
                                3 %pi   2 %pi
      (%o2)                    [-----, -------, sqrt(2) %pi]
                                  8    sqrt(3)

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

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

  Posibles valores cuando uno de los argumentos es entero negativo:

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

  `beta(a+n,b)` o `beta(a-n)` con `n` entero se simplifica si `beta_expand` vale `true`:

      (%i6) beta_expand:true$
      (%i7) [beta(a+1,b),beta(a-1,b),beta(a+1,b)/beta(a,b+1)];
                          a beta(a, b)  beta(a, b) (b + a - 1)  a
      (%o7)              [------------, ----------------------, -]
                             b + a              a - 1           b

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

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

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

      (%i8) beta(2.5,2.3);
      (%o8) .08694748611299981

      (%i9) beta(2.5,1.4+%i);
      (%o9) 0.0640144950796695 - .1502078053286415 %i

      (%i10) beta(2.5b0,2.3b0);
      (%o10) 8.694748611299969b-2

      (%i11) beta(2.5b0,1.4b0+%i);
      (%o11) 6.401449507966944b-2 - 1.502078053286415b-1 %i

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

      (%i14) beta(a,b)-beta(b,a);
      (%o14)                                 0
      (%i15) declare(a,complex,b,complex)$
      (%i16) conjugate(beta(a,b));
      (%o16)                 beta(conjugate(a), conjugate(b))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  Ejemplos:

  Simplificación para a entero positivo:

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

  Simplificación para b entero positivo:

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

  Simplificación para a y b enteros positivos:

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

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

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

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

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

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

      (%i8) beta_incomplete(0.25,0.50,0.9);
      (%o8)                          4.594959440269333
      (%i9)  fpprec:25$
      (%i10) beta_incomplete(0.25,0.50,0.9b0);
      (%o10)                    4.594959440269324086971203b0

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

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

  Resultados para argumentos complejos más generales:

      (%i14) beta_incomplete(0.25+%i,1.0+%i,1.7+%i);
      (%o14)             2.726960675662536 - .3831175704269199 %i
      (%i15) beta_incomplete(1/2,5/4*%i,2.8+%i);
      (%o15)             13.04649635168716 %i - 5.802067956270001
      (%i16)

  Expansión cuando `beta_expand` vale `true`:

      (%i23) beta_incomplete(a+1,b,z),beta_expand:true;
                                                             b  a
                         a beta_incomplete(a, b, z)   (1 - z)  z
      (%o23)             -------------------------- - -----------
                                   b + a                 b + a

      (%i24) beta_incomplete(a-1,b,z),beta_expand:true;
                                                                 b  a - 1
                 beta_incomplete(a, b, z) (- b - a + 1)   (1 - z)  z
      (%o24)     -------------------------------------- - ---------------
                                 1 - a                         1 - a

  Derivada e integral de `beta_incomplete`:

      (%i34) diff(beta_incomplete(a, b, z), z);
                                    b - 1  a - 1
      (%o34)                 (1 - z)      z
      (%i35) integrate(beta_incomplete(a, b, z), z);
                    b  a
             (1 - z)  z
      (%o35) ----------- + beta_incomplete(a, b, z) z
                b + a
                                             a beta_incomplete(a, b, z)
                                           - --------------------------
                                                       b + a
      (%i36) factor(diff(%, z));
      (%o36)              beta_incomplete(a, b, z)

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

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

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

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

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

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

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

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

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

  Ejemplos:

  Simplificación para a o b enteros positivos:

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

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

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

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

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

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

      (%i7) beta_incomplete_regularized(0.12,0.43,0.9);
      (%o7)                         .9114011367359802
      (%i8) fpprec:32$
      (%i9) beta_incomplete_regularized(0.12,0.43,0.9b0);
      (%o9)               9.1140113673598075519946998779975b-1
      (%i10) beta_incomplete_regularized(1+%i,3/3,1.5*%i);
      (%o10)             .2865367499935403 %i - 0.122995963334684
      (%i11) fpprec:20$
      (%i12) beta_incomplete_regularized(1+%i,3/3,1.5b0*%i);
      (%o12)      2.8653674999354036142b-1 %i - 1.2299596333468400163b-1

  Expansión cuando `beta_expand` vale `true`:

      (%i13) beta_incomplete_regularized(a+1,b,z);
                                                           b  a
                                                    (1 - z)  z
      (%o13) beta_incomplete_regularized(a, b, z) - ------------
                                                    a beta(a, b)
      (%i14) beta_incomplete_regularized(a-1,b,z);
      (%o14) beta_incomplete_regularized(a, b, z)
                                                           b  a - 1
                                                    (1 - z)  z
                                               - ----------------------
                                                 beta(a, b) (b + a - 1)

  Derivada e integral respecto de z:

      (%i15) diff(beta_incomplete_regularized(a,b,z),z);
                                    b - 1  a - 1
                             (1 - z)      z
      (%o15)                 -------------------
                                 beta(a, b)
      (%i16) integrate(beta_incomplete_regularized(a,b,z),z);
      (%o16) beta_incomplete_regularized(a, b, z) z
                                                                 b  a
                                                          (1 - z)  z
                a (beta_incomplete_regularized(a, b, z) - ------------)
                                                          a beta(a, b)
              - -------------------------------------------------------
                                         b + a

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

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

  The basic definition of the generalized incomplete beta function is

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

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

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

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

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

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

  Ejemplos:

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

      (%i1) beta_incomplete_generalized(2,b,z1,z2);
                                b                      b
                        (1 - z1)  (b z1 + 1) - (1 - z2)  (b z2 + 1)
      (%o1)             -------------------------------------------
                                         b (b + 1)

      (%i2) beta_incomplete_generalized(a,2,z1,z2);
                                           a                      a
                        (a (1 - z2) + 1) z2  - (a (1 - z1) + 1) z1
      (%o2)             -------------------------------------------
                                         a (a + 1)

      (%i3) beta_incomplete_generalized(3,2,z1,z2);
                        2      2                       2      2
                (1 - z1)  (3 z1  + 2 z1 + 1) - (1 - z2)  (3 z2  + 2 z2 + 1)
      (%o3)     -----------------------------------------------------------
                                            12

  Simplificación para los valores z1=0, z2=0, z1=1 o z2=1:

      (%i4) assume(a > 0, b > 0)$
      (%i5) beta_incomplete_generalized(a,b,z1,0);
      (%o5)                    - beta_incomplete(a, b, z1)

      (%i6) beta_incomplete_generalized(a,b,0,z2);
      (%o6)                    - beta_incomplete(a, b, z2)

      (%i7) beta_incomplete_generalized(a,b,z1,1);
      (%o7)              beta(a, b) - beta_incomplete(a, b, z1)

      (%i8) beta_incomplete_generalized(a,b,1,z2);
      (%o8)              beta_incomplete(a, b, z2) - beta(a, b)

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

      (%i9) beta_incomplete_generalized(1/2,3/2,0.25,0.31);
      (%o9)                        .09638178086368676

      (%i10) fpprec:32$
      (%i10) beta_incomplete_generalized(1/2,3/2,0.25,0.31b0);
      (%o10)               9.6381780863686935309170054689964b-2

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

      (%i11) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31);
      (%o11)           - .09625463003205376 %i - .003323847735353769
      (%i12) fpprec:20$
      (%i13) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31b0);
      (%o13)     - 9.6254630032054178691b-2 %i - 3.3238477353543591914b-3

  Expansión para a+n o a-n, siendo n entero positivo con `beta_expand` igual `true`:

      (%i14) beta_expand:true$
      (%i15) beta_incomplete_generalized(a+1,b,z1,z2);
                     b   a           b   a
             (1 - z1)  z1  - (1 - z2)  z2
      (%o15) -----------------------------
                         b + a
                                  a beta_incomplete_generalized(a, b, z1, z2)
                                + -------------------------------------------
                                                     b + a

      (%i16) beta_incomplete_generalized(a-1,b,z1,z2);
             beta_incomplete_generalized(a, b, z1, z2) (- b - a + 1)
      (%o16) -------------------------------------------------------
                                      1 - a
                                                b   a - 1           b   a - 1
                                        (1 - z2)  z2      - (1 - z1)  z1
                                      - -------------------------------------
                                                        1 - a

  Derivada respecto de la variable z1 e integrales respecto de z1 y z2:

      (%i17) diff(beta_incomplete_generalized(a,b,z1,z2),z1);
                                            b - 1   a - 1
      (%o17)                      - (1 - z1)      z1

      (%i18) integrate(beta_incomplete_generalized(a,b,z1,z2),z1);
      (%o18) beta_incomplete_generalized(a, b, z1, z2) z1
                                              + beta_incomplete(a + 1, b, z1)

      (%i19) integrate(beta_incomplete_generalized(a,b,z1,z2),z2);
      (%o19) beta_incomplete_generalized(a, b, z1, z2) z2
                                              - beta_incomplete(a + 1, b, z2)

Variable opcional: beta_expand

  Valor por defecto: false

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

Variable opcional: beta_args_sum_to_integer

  Valor por defecto: false

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

Función: psi [n](x)

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

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

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

Variable opcional: maxpsiposint

  Valor por defecto: 20

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

Variable opcional: maxpsinegint

  Valor por defecto: -10

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

Variable opcional: maxpsifracnum

  Valor por defecto: 6

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

Variable opcional: maxpsifracdenom

  Valor por defecto: 6

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

Función: makefact (expr)

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

  Véase también `makegamma`.

Función: numfactor (expr)

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

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

[ < ] | [ > ] |  | [ << ] | [ 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_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`.

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 Viktor T. Toth on septiembre, 27 2018 using texi2html 1.76.