Funciones y variables para QUADPACK (Manual de Maxima 5.44.0)

Anterior: Introducción a QUADPACK, Subir: Integración [Índice general][Índice]

### 19.4 Funciones y variables para QUADPACK

Función: quad_qag (f(x), x, a, b, key, [epsrel, epsabs, limit])
Función: quad_qag (f, x, a, b, key, [epsrel, epsabs, limit])

  Integración de una función general en un intervalo finito. La función `quad_qag` implementa un integrador global adaptativo simple utilizando una estrategia de Aind (Piessens, 1973). Se puede escoger entre seis pares de fórmulas de cuadratura de Gauss-Kronrod para la regla de evaluación. Las reglas de rango superior son útiles en los casos en los que los integrandos tienen un alto grado de oscilación.

  La función `quad_qag` calcula numéricamente la integral

  integrate (f(x), x, a, b)

  utilizando un integrador adaptativo simple.

  La función a integrar es f(x), con variable independiente x, siendo el intervalo de integración el comprendido entre a y b. El argumento key indica el integrador a utilizar y debe ser un número entero entre 1 y 6, ambos inclusive. El valor de key selecciona el orden de la regla de integración de Gauss-Kronrod. Las reglas de rango superior son útiles en los casos en los que los integrandos tienen un alto grado de oscilación.

  El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima.

  La integración numérica se hace de forma adaptativa particionando la región de integración en subintervalos hasta conseguir la precisión requerida.

  Los argumentos opcionales pueden especificarse en cualquier orden. Todos ellos toman la forma `key=val`. Tales argumentos son:

  `epsrel`

    Error relativo deseado de la aproximación. El valor por defecto es 1d-8.

  `epsabs`

    Error absoluto deseado de la aproximación. El valor por defecto es 0.

  `limit`

    Tamaño del array interno utilizado para realizar la cuadratura. limit es el número máximo de subintervalos a utilizar. El valor por defecto es 200.

  La función `quad_qag` devuelve una lista de cuatro elementos:

  - la aproximación a la integral,
  - el error absoluto estimado de la aproximación,
  - el número de evaluaciones del integrando,
  - un código de error.

  El código de error (el cuarto elemento del resultado) puede tener los siguientes valores:

  `0`

    si no ha habido problemas;

  `1`

    si se utilizaron demasiados intervalos;

  `2`

    si se encontró un número excesivo de errores de redondeo;

  `3`

    si el integrando ha tenido un comportamiento extraño frente a la integración;

  `6`

    si los argumentos de entrada no son válidos.

  Ejemplos:

      (%i1) quad_qag (x^(1/2)*log(1/x), x, 0, 1, 3, 'epsrel=5d-8);
      (%o1)    [.4444444444492108, 3.1700968502883E-9, 961, 0]
      (%i2) integrate (x^(1/2)*log(1/x), x, 0, 1);
                                      4
      (%o2)                           -
                                      9

Función: quad_qags (f(x), x, a, b, [epsrel, epsabs, limit])
Función: quad_qags (f, x, a, b, [epsrel, epsabs, limit])

  Integración de una función general en un intervalo finito. La función `quad_qags` implementa la subdivisión de intervalos global adaptativa con extrapolación (de Doncker, 1978) mediante el algoritmo Epsilon (Wynn, 1956).

  La función `quad_qags` calcula la integral

  integrate (f(x), x, a, b)

  La función a integrar es f(x), de variable independiente x, siendo el intervalo de integración el comprendido entre a y b.

  El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima.

  Los argumentos opcionales pueden especificarse en cualquier orden. Todos ellos toman la forma `key=val`. Tales argumentos son:

  `epsrel`

    Error relativo deseado de la aproximación. El valor por defecto es 1d-8.

  `epsabs`

    Error absoluto deseado de la aproximación. El valor por defecto es 0.

  `limit`

    Tamaño del array interno utilizado para realizar la cuadratura. limit es el número máximo de subintervalos a utilizar. El valor por defecto es 200.

  La función `quad_qags` devuelve una lista de cuatro elementos:

  - la aproximación a la integral,
  - el error absoluto estimado de la aproximación,
  - el número de evaluaciones del integrando,
  - un código de error.

  El código de error (el cuarto elemento del resultado) puede tener los siguientes valores:

  `0`

    si no ha habido problemas;

  `1`

    si se utilizaron demasiados intervalos;

  `2`

    si se encontró un número excesivo de errores de redondeo;

  `3`

    si el integrando ha tenido un comportamiento extraño frente a la integración;

  `4`

    fallo de convergencia;

  `5`

    la integral es probablemente divergente o de convergencia lenta;

  `6`

    si los argumentos de entrada no son válidos.

  Ejemplos:

      (%i1) quad_qags (x^(1/2)*log(1/x), x, 0, 1, 'epsrel=1d-10);
      (%o1)   [.4444444444444448, 1.11022302462516E-15, 315, 0]

  Nótese que `quad_qags` es más precisa y eficiente que `quad_qag` para este integrando.

Función: quad_qagi (f(x), x, a, b, [epsrel, epsabs, limit])
Función: quad_qagi (f, x, a, b, [epsrel, epsabs, limit])

  Integración de una función general en un intervalo infinito o semi-infinito. El intervalo se proyecta sobre un intervalo finito y luego se aplica la misma estrategia que en `quad_qags`.

  La función `quad_qagi` calcula cualquiera las siguientes integrales:

  integrate (f(x), x, a, inf)

  integrate (f(x), x, minf, a)

  integrate (f(x), x, minf, inf)

  utilizando la rutina QAGI de Quadpack QAGI. La función a integrar es f(x), con variable independiente x, siendo el intervalo de integración de rango infinito.

  El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima.

  Uno de los límites de integración debe ser infinito. De no ser así, `quad_qagi` devolverá una forma nominal.

  Los argumentos opcionales pueden especificarse en cualquier orden. Todos ellos toman la forma `key=val`. Tales argumentos son:

  `epsrel`

    Error relativo deseado de la aproximación. El valor por defecto es 1d-8.

  `epsabs`

    Error absoluto deseado de la aproximación. El valor por defecto es 0.

  `limit`

    Tamaño del array interno utilizado para realizar la cuadratura. limit es el número máximo de subintervalos a utilizar. El valor por defecto es 200.

  La función `quad_qagi` devuelve una lista de cuatro elementos:

  - la aproximación a la integral,
  - el error absoluto estimado de la aproximación,
  - el número de evaluaciones del integrando,
  - un código de error.

  El código de error (el cuarto elemento del resultado) puede tener los siguientes valores:

  `0`

    si no ha habido problemas;

  `1`

    si se utilizaron demasiados intervalos;

  `2`

    si se encontró un número excesivo de errores de redondeo;

  `3`

    si el integrando ha tenido un comportamiento extraño frente a la integración;

  `4`

    fallo de convergencia;

  `5`

    la integral es probablemente divergente o de convergencia lenta;

  `6`

    si los argumentos de entrada no son válidos.

  Ejemplos:

      (%i1) quad_qagi (x^2*exp(-4*x), x, 0, inf, 'epsrel=1d-8);
      (%o1)        [0.03125, 2.95916102995002E-11, 105, 0]
      (%i2) integrate (x^2*exp(-4*x), x, 0, inf);
                                     1
      (%o2)                          --
                                     32

Función: quad_qawc (f(x), x, c, a, b, [epsrel, epsabs, limit])
Función: quad_qawc (f, x, c, a, b, [epsrel, epsabs, limit])

  Calcula el valor principal de Cauchy de f(x)/(x - c) en un intervalo finito (a, b) para una c dada. La estrategia es global adaptativa, utilizando la integración de Clenshaw-Curtis modificada en los subintervalos que contienen a x = c.

  La función `quad_qawc` calcula el valor principal de Cauchy de

  integrate (f(x)/(x - c), x, a, b)

  utilizando la rutina QAWC de Quadpack. La función a integrar es `f(x)/(x - c)`, con variable independiente x, siendo el intervalo de integración el comprendido entre a y b.

  El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima.

  Los argumentos opcionales pueden especificarse en cualquier orden. Todos ellos toman la forma `key=val`. Tales argumentos son:

  `epsrel`

    Error relativo deseado de la aproximación. El valor por defecto es 1d-8.

  `epsabs`

    Error absoluto deseado de la aproximación. El valor por defecto es 0.

  `limit`

    Tamaño del array interno utilizado para realizar la cuadratura. limit es el número máximo de subintervalos a utilizar. El valor por defecto es 200.

  `quad_qawc` returns a list of four elements:

  - la aproximación a la integral,
  - el error absoluto estimado de la aproximación,
  - el número de evaluaciones del integrando,
  - un código de error.

  El código de error (el cuarto elemento del resultado) puede tener los siguientes valores:

  `0`

    si no ha habido problemas;

  `1`

    si se utilizaron demasiados intervalos;

  `2`

    si se encontró un número excesivo de errores de redondeo;

  `3`

    si el integrando ha tenido un comportamiento extraño frente a la integración;

  `6`

    si los argumentos de entrada no son válidos.

  Ejemplos:

      (%i1) quad_qawc (2^(-5)*((x-1)^2+4^(-5))^(-1), x, 2, 0, 5,
                       'epsrel=1d-7);
      (%o1)    [- 3.130120337415925, 1.306830140249558E-8, 495, 0]
      (%i2) integrate (2^(-alpha)*(((x-1)^2 + 4^(-alpha))*(x-2))^(-1),
                       x, 0, 5);
      Principal Value
              alpha        9 4                 9
             4      log(-------------- + --------------)
                         alpha + 3        alpha + 3
                        4          + 4   4          + 4
      (%o2) (-------------------------------------------
                               alpha
                            2 4      + 2
          3 alpha                   3 alpha
          -------                   -------
             2          alpha/2        2              alpha/2
         4        atan(4       )   4        atan(- 4 4       )
       - ----------------------- + ---------------------------)
                alpha                       alpha
               4      + 1                  4      + 1
        alpha
      /2
      (%i3) ev (%, alpha=5, numer);
      (%o3)                    - 3.130120337415917

Función: quad_qawf (f(x), x, a, omega, trig, [epsabs, limit, maxp1, limlst])
Función: quad_qawf (f, x, a, omega, trig, [epsabs, limit, maxp1, limlst])

  Calcula la transformada seno o coseno de Fourier en un intervalo semi-infinito. Se aplica el mismo método que en `quad_qawo` a sucesivos intervalos finitos, acelerando la convergencia mediante el algoritmo Epsilon (Wynn, 1956).

  La función `quad_qawf` calcula la integral

  integrate (f(x)*w(x), x, a, inf)

  La función peso w se selecciona mediante trig:

  `cos`

    w(x) = cos (omega x)

  `sin`

    w(x) = sin (omega x)

  El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima

  Los argumentos opcionales pueden especificarse en cualquier orden. Todos ellos toman la forma `key=val`. Tales argumentos son:

  `epsabs`

    El error absoluto deseado para la aproximación. El valor por defecto es 1d-10.

  `limit`

    Tamaño del arreglo interno de trabajo. (limit - limlst)/2 es el número máximo de subintervalos para la partición. El valor por defecto es 200.

  `maxp1`

    Número máximo de momentos de Chebyshev. Debe ser mayor que 0. El valor por defecto es 100.

  `limlst`

    Cota superior del número de ciclos. Debe ser mayor o igual que 3. El valor por defecto es 10.

  `quad_qawf` returns a list of four elements:

  - la aproximación a la integral,
  - el error absoluto estimado de la aproximación,
  - el número de evaluaciones del integrando,
  - un código de error.

  El código de error (el cuarto elemento del resultado) puede tener los siguientes valores:

  `0`

    si no ha habido problemas;

  `1`

    si se utilizaron demasiados intervalos;

  `2`

    si se encontró un número excesivo de errores de redondeo;

  `3`

    si el integrando ha tenido un comportamiento extraño frente a la integración;

  `6`

    si los argumentos de entrada no son válidos.

  Ejemplos:

      (%i1) quad_qawf (exp(-x^2), x, 0, 1, 'cos, 'epsabs=1d-9);
      (%o1)   [.6901942235215714, 2.84846300257552E-11, 215, 0]
      (%i2) integrate (exp(-x^2)*cos(x), x, 0, inf);
                                - 1/4
                              %e      sqrt(%pi)
      (%o2)                   -----------------
                                      2
      (%i3) ev (%, numer);
      (%o3)                   .6901942235215714

Función: quad_qawo (f(x), x, a, b, omega, trig, [epsrel, epsabs, limit, maxp1, limlst])
Función: quad_qawo (f, x, a, b, omega, trig, [epsrel, epsabs, limit, maxp1, limlst])

  Integración de cos(omega x) f(x) o sin(omega x) f(x) en un intervalo finito, siendo omega una constante. La regla de evaluación se basa en la técnica modificada de Clenshaw-Curtis. La función `quad_qawo` aplica la subdivisión adaptativa con extrapolación, de forma similar a `quad_qags`.

  La función `quad_qawo` realiza la integración utilizando la rutina QAWO de Quadpack:

  integrate (f(x)*w(x), x, a, b)

  La función peso w se selecciona mediante trig:

  `cos`

    w(x) = cos (omega x)

  `sin`

    w(x) = sin (omega x)

  El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima

  Los argumentos opcionales pueden especificarse en cualquier orden. Todos ellos toman la forma `key=val`. Tales argumentos son:

  `epsrel`

    El error absoluto deseado para la aproximación. El valor por defecto es 1d-8.

  `epsabs`

    Error absoluto deseado de la aproximación. El valor por defecto es 0.

  `limit`

    Tamaño del arreglo interno de trabajo. limit/2 es el número máximo de subintervalos para la partición. El valor por defecto es 200.

  `maxp1`

    Número máximo de momentos de Chebyshev. Debe ser mayor que 0. El valor por defecto es 100.

  `limlst`

    Cota superior del número de ciclos. Debe ser mayor o igual que 3. El valor por defecto es 10.

  `quad_qawo` returns a list of four elements:

  - la aproximación a la integral,
  - el error absoluto estimado de la aproximación,
  - el número de evaluaciones del integrando,
  - un código de error.

  El código de error (el cuarto elemento del resultado) puede tener los siguientes valores:

  `0`

    si no ha habido problemas;

  `1`

    si se utilizaron demasiados intervalos;

  `2`

    si se encontró un número excesivo de errores de redondeo;

  `3`

    si el integrando ha tenido un comportamiento extraño frente a la integración;

  `6`

    si los argumentos de entrada no son válidos.

  Ejemplos:

      (%i1) quad_qawo (x^(-1/2)*exp(-2^(-2)*x), x, 1d-8, 20*2^2, 1, cos);
      (%o1)     [1.376043389877692, 4.72710759424899E-11, 765, 0]
      (%i2) rectform (integrate (x^(-1/2)*exp(-2^(-alpha)*x) * cos(x),
                                 x, 0, inf));
                         alpha/2 - 1/2            2 alpha
              sqrt(%pi) 2              sqrt(sqrt(2        + 1) + 1)
      (%o2)   -----------------------------------------------------
                                     2 alpha
                               sqrt(2        + 1)
      (%i3) ev (%, alpha=2, numer);
      (%o3)                     1.376043390090716

Función: quad_qaws (f(x), x, a, b, alpha, beta, wfun, [epsrel, epsabs, limit])
Función: quad_qaws (f, x, a, b, alpha, beta, wfun, [epsrel, epsabs, limit])

  Integración de w(x) f(x) en un intervalo finito [a, b], siendo w una función de la forma (x - a)^alpha (b - x)^beta v(x), con v(x) igual a 1, a log(x - a), a log(b - x) o a log(x - a) log(b - x) y con alpha > -1, y beta > -1. Se aplica una estrategia de subdivisión adaptativa global, con integración de Clenshaw-Curtis modificada en los subintervalos que contienen a a y a b.

  La función `quad_qaws` realiza la integración utizando la rutina QAWS de Quadpack:

  integrate (f(x)*w(x), x, a, b)

  La función peso w se selecciona mediante wfun:

  `1`

    w(x) = (x - a)^alfa (b - x)^beta

  `2`

    w(x) = (x - a)^alfa (b - x)^beta log(x - a)

  `3`

    w(x) = (x - a)^alfa (b - x)^beta log(b - x)

  `4`

    w(x) = (x - a)^alfa (b - x)^beta log(x - a) log(b - x)

  El integrando se puede especificar con el nombre de una función u operador de Maxima o de Lisp, como una expresión lambda o como una expresión general de Maxima

  Los argumentos opcionales pueden especificarse en cualquier orden. Todos ellos toman la forma `key=val`. Tales argumentos son:

  `epsrel`

    El error absoluto deseado para la aproximación. El valor por defecto es 1d-8.

  `epsabs`

    Error absoluto deseado de la aproximación. El valor por defecto es 0.

  `limit`

    Tamaño del array interno utilizado para realizar la cuadratura. (limit - limlst)/2 es el número máximo de subintervalos a utilizar. El valor por defecto es 200.

  `quad_qaws` returns a list of four elements:

  - la aproximación a la integral,
  - el error absoluto estimado de la aproximación,
  - el número de evaluaciones del integrando,
  - un código de error.

  El código de error (el cuarto elemento del resultado) puede tener los siguientes valores:

  `0`

    si no ha habido problemas;

  `1`

    si se utilizaron demasiados intervalos;

  `2`

    si se encontró un número excesivo de errores de redondeo;

  `3`

    si el integrando ha tenido un comportamiento extraño frente a la integración;

  `6`

    si los argumentos de entrada no son válidos.

  Ejemplos:

      (%i1) quad_qaws (1/(x+1+2^(-4)), x, -1, 1, -0.5, -0.5, 1,
                       'epsabs=1d-9);
      (%o1)     [8.750097361672832, 1.24321522715422E-10, 170, 0]
      (%i2) integrate ((1-x*x)^(-1/2)/(x+1+2^(-alpha)), x, -1, 1);
             alpha
      Is  4 2      - 1  positive, negative, or zero?

      pos;
                                alpha         alpha
                         2 %pi 2      sqrt(2 2      + 1)
      (%o2)              -------------------------------
                                     alpha
                                  4 2      + 2
      (%i3) ev (%, alpha=4, numer);
      (%o3)                     8.750097361672829

Fución: quad_qagp (f(x), x, a, b, points, [epsrel, epsabs, limit])
Fución: quad_qagp (f, x, a, b, points, [epsrel, epsabs, limit])

  Integra una función general sobre un intervalo acotado. La función `quad_qagp` implementa un método adaptativo global de subdivisión del intervalo con extrapolación (de Doncker, 1978) basado en el algoritmo Epsilon (Wynn, 1956).

  `quad_qagp` calcula la integral

  integrate (f(x), x, a, b)

  La función a integrar es f(x), con variable independiente x, en el intervalo limitado por a y b.

  El integrando puede especificarse mediante el nombre de una función de Maxima o de Lisp o un operador, como una expresión lambda de Maxima, o como una expresión general de Maxima.

  Para ayudar al integrador, el usuario debe aportar una lista de puntos donde el integrando es singular o discontinuo.

  Las opciones se suministran como argumentos y se pueden escribir en cualquier orden. Deben tomar la forma `opción=valor`. Las opciones son:

  `epsrel`

    Error relativo de aproximación deseado. Valor por defecto es 1d-8.

  `epsabs`

    Error absoluto de aproximación deseado. Valor por defecto es 0.

  `limit`

    Tamaño del array interno de trabajo. limit es el máximo número de subintervalos a utilizar. Valor por defecto es 200.

  `quad_qagp` devuelve una lista con cuatro elementos:

  - una aproximación a la integral,
  - el error absoluto estimado de la aproximación,
  - el número de evaluaciones del integrando,
  - un código de error.

  El código de error (cuarto elemento de la lista devuelta) puede tener los siguientes valores:

  `0`

    no se encontraron errores;

  `1`

    se han hecho demasiados subintervalos;

  `2`

    se detectó un error de redondeo muy grande;

  `3`

    se ha observado un comportamiento del integrando extremadamente malo;

  `4`

    fallo de convergencia;

  `5`

    la integral es probablemente divergengente o converge muy lentamente;

  `6`

    entrada inválida.

  Ejemplos:

      (%i1) quad_qagp(x^3*log(abs((x^2-1)*(x^2-2))),x,0,3,[1,sqrt(2)]);
      (%o1)   [52.74074838347143, 2.6247632689546663e-7, 1029, 0]

      (%i2) quad_qags(x^3*log(abs((x^2-1)*(x^2-2))), x, 0, 3);
      (%o2)   [52.74074847951494, 4.088443219529836e-7, 1869, 0]

  El integrando tiene singularidades en `1` y `sqrt(2)`, de manera que suministramos estos puntos a `quad_qagp`. También se observa que `quad_qagp` es más exacto y eficiente que `quad_qags`.

Fución: quad_control (parameter, [value])

  Controla la gestión de los errores de `QUADPACK`. El parámetro debe ser uno de los siguientes símbolos:

  `current_error`

    El número de error actual.

  `control`

    Controla si los mensajes se imprimen o no. Si el valor es cero o menor, los mensajes se suprimen.

  `max_message`

    El máximo número de veces que se imprime cualquier mensaje.

  Si no se da value, entonces se devuelve el valor actual asociado a parameter. En cambio, si se da value, se hace la asignación correspondiente a parameter, adquiriendo este nuevo valor.

Anterior: Introducción a QUADPACK, Subir: Integración [Índice general][Índice]