Funciones y variables para integración (Manual de Maxima 5.45.0)

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

### 19.2 Funciones y variables para integración

Función: changevar (expr, f(x,y), y, x)

  Hace el cambio de variable dado por `f(x,y) = 0` en todas las integrales que aparecen en expr con la integración respecto de x. La nueva variable será y.

      (%i1) assume(a > 0)$
      (%i2) 'integrate (%e**sqrt(a*y), y, 0, 4);
                            4
                           /
                           [    sqrt(a) sqrt(y)
      (%o2)                I  %e                dy
                           ]
                           /
                            0
      (%i3) changevar (%, y-z^2/a, z, y);
                            0
                           /
                           [                abs(z)
                         2 I            z %e       dz
                           ]
                           /
                            - 2 sqrt(a)
      (%o3)            - ----------------------------
                                      a

  Si una expresión contiene formas nominales, como aquélla en la que aparece `'integrate` en el ejemplo, podrá ser evaluada por `ev` si se utiliza el término `nouns`. Por ejemplo, la expresión devuelta por `changevar` se puede evaluar haciendo `ev (%o3, nouns)`.

  La función `changevar` también se puede utilizar para cambiar los índices de una suma o producto. Sin embargo, debe tenerse en cuenta que cuando se realiza un cambio en una suma o producto, el mismo debe expresarse en términos de sumas, como `i = j+ ...`, no como una función de mayor grado.

  Ejemplo:

      (%i4) sum (a[i]*x^(i-2), i, 0, inf);
                               inf
                               ====
                               \         i - 2
      (%o4)                     >    a  x
                               /      i
                               ====
                               i = 0
      (%i5) changevar (%, i-2-n, n, i);
                              inf
                              ====
                              \               n
      (%o5)                    >      a      x
                              /        n + 2
                              ====
                              n = - 2

Función: dblint (f, r, s, a, b)

  Es una rutina para integrales dobles escrita en lenguaje Maxima y posteriormente traducida y compilada a código máquina. La instrucción `load (dblint)` carga esta función. Utiliza el método de Simpson en las dos direcciones `x` e `y` para calcular

      /b /s(x)
      |  |
      |  |    f(x,y) dy dx
      |  |
      /a /r(x)

  La función f debe ser una función traducida o compilada de dos variables, a la vez que r y s deben ser cada una de ellas una función traducida o compilada de una variable, mientras que a y b deben ser números en coma flotante. La rutina tiene dos variables globales que determinan el número de divisiones de los intervalos `x` e `y`: `dblint_x` y `dblint_y`, ambos con un valor por defecto de 10, pero que pueden cambiarse de forma independiente a otros valores enteros (hay `2*dblint_x+1` puntos a calcular en la dirección `x` y `2*dblint_y+1` en la dirección `y`). La rutina subdivide el eje X y luego para cada valor de X calcula primero `r(x)` y `s(x)`; entonces se subdivide el eje Y entre `r(x)` y `s(x)`, evaluándose la integral a lo largo del eje Y aplicando la regla de Simpson; a continuación, se evalúa la integral a lo largo del eje X utilizando también la regla de Simpson tomando como valores de función las integrales sobre Y. Este procedimiento puede ser numéricamente inestable por múltiples motivos, pero es razonablemente rápido: evítese su uso con funciones con grandes oscilaciones o que tengan singularidades. Las integrales del eje Y dependen de la proximidad de los límites `r(x)` y `s(x)`, de manera que si la distancia `s(x) - r(x)` varía rápidamente con X, puede dar lugar errores importantes debido a truncamientos de diferente amplitud en las integrales de Y. Se puede aumentar `dblint_x` y `dblint_y` al objeto de mejorar el recubrimiento de la región de integración, pero a costa del tiempo de cómputo. Es necesario que las funciones f, r y s estén traducidas o compiladas antes de utilizar `dblint`, lo cual redundará en una mejora del tiempo de ejecución de varios órdenes de magnitud respecto de la ejecución de código interpretado.

Función: defint (expr, x, a, b)

  Intenta calcular una integral definida. La función `defint` es invocada por `integrate` cuando se especifican los límites de integración, por ejemplo `integrate (expr, x, a, b)`. Así, desde el punto de vista del usuario, es suficiente con utilizar `integrate`.

  La función `defint` devuelve una expresión simbólica, bien sea el resultado calculado o la forma nominal. Véase `quad_qag` y sus funciones relacionadas para aproximaciones numéricas de integrales definidas.

Variable optativa: erfflag

  Valor por defecto: `true`

  Si `erfflag` vale `false`, la función `risch` no introduce la función `erf` en el resultado si no había ninguna en el integrando.

Función: ilt (expr, s, t)

  Calcula la transformada inversa de Laplace de expr con respecto de s y parámetro t. El argumento expr debe ser una fracción de polinomios cuyo denominador tenga sólo factores lineales y cuadráticos. Utilizando las funciones `laplace` y `ilt`, junto con las funciones `solve` o `linsolve`, el usuario podrá resolver ciertas ecuaciones integrales.

      (%i1) 'integrate (sinh(a*x)*f(t-x), x, 0, t) + b*f(t) = t**2;
                    t
                   /
                   [                                    2
      (%o1)        I  f(t - x) sinh(a x) dx + b f(t) = t
                   ]
                   /
                    0
      (%i2) laplace (%, t, s);
                                     a laplace(f(t), t, s)   2
      (%o2)  b laplace(f(t), t, s) + --------------------- = --
                                             2    2           3
                                            s  - a           s
      (%i3) linsolve ([%], ['laplace(f(t), t, s)]);
                                              2      2
                                           2 s  - 2 a
      (%o3)     [laplace(f(t), t, s) = --------------------]
                                          5         2     3
                                       b s  + (a - a  b) s
      (%i4) ilt (rhs (first (%)), s, t);
      Is  a b (a b - 1)  positive, negative, or zero?

      pos;
                     sqrt(a b (a b - 1)) t
              2 cosh(---------------------)       2
                               b               a t
      (%o4) - ----------------------------- + -------
                    3  2      2               a b - 1
                   a  b  - 2 a  b + a

                                                             2
                                                   + ------------------
                                                      3  2      2
                                                     a  b  - 2 a  b + a

Variable opcional: intanalysis

  Valor por defecto: `true`

  Cuando vale `true`, la integración definida trata de encontrar polos en el integrando dentro del intervalo de integración. Si encuentra alguno, entonces la integral se calcula como valor principal. Si `intanalysis` vale `false`, entonces no se realiza esta comprobaciÃ³n y la integración se realiza sin tener en cuenta los polos.

  Véase también `ldefint`.

  Ejemplos:

  Maxima puede calcular las siguientes integrales cuando a `intanalysis` se le asigna el valor `false`:

      (%i1) integrate(1/(sqrt(x)+1),x,0,1);
                                      1
                                     /
                                     [       1
      (%o1)                          I  ----------- dx
                                     ]  sqrt(x) + 1
                                     /
                                      0

      (%i2) integrate(1/(sqrt(x)+1),x,0,1),intanalysis:false;
      (%o2)                            2 - 2 log(2)

      (%i3) integrate(cos(a)/sqrt((tan(a))^2 +1),a,-%pi/2,%pi/2);
      The number 1 isn't in the domain of atanh
       -- an error. To debug this try: debugmode(true);

      (%i4) intanalysis:false$
      (%i5) integrate(cos(a)/sqrt((tan(a))^2+1),a,-%pi/2,%pi/2);
                                            %pi
      (%o5)                                 ---
                                             2

Función: integrate (expr, x)
Función: integrate (expr, x, a, b)

  Calcula simbólicamente la integral de expr respecto de x. La llamada `integrate (expr, x)` resuelve una integral indefinida, mientras que `integrate (expr, x, a, b)` resuelve una integral definida con límites de integración a y b. Los límites no pueden contener a x. El argumento a no necesita ser menor que b. Si b es igual a a, `integrate` devuelve cero.

  Véase `quad_qag` y funciones relacionadas para la aproximación numérica de integrales definidas. Véase `residue` para el cálculo de residuos (integración compleja). Véase `antid` para un método alternativo de resolución de integrales indefinidas.

  Se obtendrá una integral (es decir, una expresión sin `integrate`) si `integrate` tiene éxito en el cálculo. En otro caso, la respuesta es la forma nominal de la integral (esto es, el operador `'integrate` precedido de apóstrofo) o una expresión que contiene una o más formas nominales. La forma nominal de `integrate` se muestra con un símbolo integral.

  En ciertos casos es útil proporcionar una forma nominal ’a mano’, haciendo preceder `integrate` con una comilla simple o apóstrofo, como en `'integrate (expr, x)`. Por ejemplo, la integral puede depender de algunos parámetros que todavía no han sido calculados. La forma nominal puede aplicarse después a sus argumentos haciendo `ev (i, nouns)` donde i es la forma nominal de interés.

  La función `integrate` trata de manera diferente las integrales definidas de las indefinidas, empleando una batería de heurísticas especial para cada caso. Casos especiales de integrales definidas incluyen las que tienen límites de integración iguales a cero o a infinito (`inf` o `minf`), funciones trigonométricas con límites de integración igual a cero y `%pi` o `2 %pi`, funciones racionales, integrales relacionadas con las funciones `beta` y `psi` y algunas integrales logarítmicas y trigonométricas. El tratamiento de funciones racionales puede incluir el cálculo de residuos. Si no se reconoce ninguno de los casos especiales, se intenta resolver la integral idefinida y evaluarla en los límites de integración. Esto incluye tomar límites cuando alguno de los extremos del intervalo de integración se acerca a más infinito o a menos infinito; véase también `ldefint`.

  Casos especiales de integrales indefinidas incluyen a las funciones trigonométricas, exponenciales, logarítmicas y racionales. La función `integrate` también hace uso de una pequeña tabla de integrales elementales.

  La función `integrate` puede llevar a cabo cambios de variable si el integrando es de la forma `f(g(x)) * diff(g(x), x)`, entonces `integrate` trata de encontrar una subexpresión de `g(x)` tal que la derivada de `g(x)` divida el integrando. Esta búsqueda puede hacer uso de las derivadas establecidas con la función `gradef`. Véanse también `changevar` y `antid`.

  Si ninguna de las heurísticas descritas resuelve la integral indefinida, se ejecuta el algoritmo de Risch. La variable `risch` puede utilizarse como una `evflag`, en una llamada a `ev` o en la línea de comandos por ejemplo, `ev (integrate (expr, x), risch)` o `integrate (expr, x), risch`. Si `risch` está presenta, `integrate` llama a la función `risch` sin intentar primero las heurísticas. Véase también `risch`.

  La función `integrate` opera únicamente con relaciones funcionales que se representen explícitamente con la notación `f(x)`, sin considerar las dependencias implícitas establecidas mediante la función `depends`.

  Es posible que `integrate` necesite conocer alguna propiedad de alguno de los parámetros presentes en el integrando, en cuyo caso `integrate` consultará en primer lugar la base de datos creada con `assume`, y si la variable de interés no se encuentra ahí, `integrate` le preguntará al usuario. Dependiendo de la pregunta, posibles respuestas son: `yes;`, `no;`, `pos;`, `zero;` o `neg;`.

  Por defecto, `integrate` no se considera lineal. Véanse `declare` y `linear`.

  La función `integrate` intentará la integración por partes sólo en casos especiales.

  Ejemplos:

  - Integrales elementales indefinidas y definidas.

        (%i1) integrate (sin(x)^3, x);
                                   3
                                cos (x)
        (%o1)                   ------- - cos(x)
                                   3
        (%i2) integrate (x/ sqrt (b^2 - x^2), x);
                                         2    2
        (%o2)                    - sqrt(b  - x )
        (%i3) integrate (cos(x)^2 * exp(x), x, 0, %pi);
                                       %pi
                                   3 %e      3
        (%o3)                      ------- - -
                                      5      5
        (%i4) integrate (x^2 * exp(-x^2), x, minf, inf);
                                    sqrt(%pi)
        (%o4)                       ---------
                                        2

  - Utilización de `assume` e interacción.

        (%i1) assume (a > 1)$
        (%i2) integrate (x**a/(x+1)**(5/2), x, 0, inf);
            2 a + 2
        Is  -------  an integer?
               5

        no;
        Is  2 a - 3  positive, negative, or zero?

        neg;
                                           3
        (%o2)                  beta(a + 1, - - a)
                                           2

  - Cambio de variable. En este ejemplo hay dos cambios de variable: uno utilizando una derivada establecida con `gradef` y otra utilizando la derivada `diff(r(x))` de una función no especificada `r(x)`.

        (%i3) gradef (q(x), sin(x**2));
        (%o3)                         q(x)
        (%i4) diff (log (q (r (x))), x);
                              d               2
                             (-- (r(x))) sin(r (x))
                              dx
        (%o4)                ----------------------
                                    q(r(x))
        (%i5) integrate (%, x);
        (%o5)                     log(q(r(x)))

  - El valor devuelto contiene la forma nominal `'integrate`. En este ejemplo, Maxima puede extraer un factor del denominador de una función racional, pero no puede factorizar el resto. La función `grind` muestra la forma nominal `'integrate` del resultado. Véase también `integrate_use_rootsof` para más información sobre integrales de funciones racionales.

        (%i1) expand ((x-4) * (x^3+2*x+1));
                            4      3      2
        (%o1)              x  - 4 x  + 2 x  - 7 x - 4
        (%i2) integrate (1/%, x);
                                      /  2
                                      [ x  + 4 x + 18
                                      I ------------- dx
                                      ]  3
                         log(x - 4)   / x  + 2 x + 1
        (%o2)            ---------- - ------------------
                             73               73
        (%i3) grind (%);
        log(x-4)/73-('integrate((x^2+4*x+18)/(x^3+2*x+1),x))/73$

  - Definición de una función mediante una integral. El cuerpo de una función no se evalúa cuando ésta se define, de manera que el cuerpo de `f_1` en este ejemplo contiene la forma nominal de `integrate`. El operador comilla-comilla `''` hace que se evalúe la integral y su resultado será el que defina a la función `f_2`.

        (%i1) f_1 (a) := integrate (x^3, x, 1, a);
                                             3
        (%o1)           f_1(a) := integrate(x , x, 1, a)
        (%i2) ev (f_1 (7), nouns);
        (%o2)                          600
        (%i3) /* Note parentheses around integrate(...) here */
              f_2 (a) := ''(integrate (x^3, x, 1, a));
                                           4
                                          a    1
        (%o3)                   f_2(a) := -- - -
                                          4    4
        (%i4) f_2 (7);
        (%o4)                          600

Variable del sistema: integration_constant

  Valor por defecto: `%c`

  Cuando una constante de integración se crea durante la integración definida de una ecuación, el nombre de la constante se construye concatenando `integration_constant` y `integration_constant_counter`.

  A `integration_constant` se le puede asignar un símbolo cualquiera.

  Ejemplos:

      (%i1) integrate (x^2 = 1, x);
                                 3
                                x
      (%o1)                     -- = x + %c1
                                3

      (%i2) integration_constant : 'k;
      (%o2)                           k

      (%i3) integrate (x^2 = 1, x);
                                  3
                                 x
      (%o3)                      -- = x + k2
                                 3

Variable del sistema: integration_constant_counter

  Valor por defecto: 0

  Cuando una constante de integración se crea durante la integración definida de una ecuación, el nombre de la constante se construye concatenando `integration_constant` y `integration_constant_counter`.

  La variable `integration_constant_counter` se incrementa antes de construir la constante de integración siguiente.

  Ejemplos:

      (%i1) integrate (x^2 = 1, x);
                                 3
                                x
      (%o1)                     -- = x + %c1
                                3

      (%i2) integrate (x^2 = 1, x);
                                 3
                                x
      (%o2)                     -- = x + %c2
                                3

      (%i3) integrate (x^2 = 1, x);
                                 3
                                x
      (%o3)                     -- = x + %c3
                                3

      (%i4) reset (integration_constant_counter);
      (%o4)            [integration_constant_counter]

      (%i5) integrate (x^2 = 1, x);
                                 3
                                x
      (%o5)                     -- = x + %c1
                                3

Variable optativa: integrate_use_rootsof

  Valor por defecto: `false`

  Si `integrate_use_rootsof` vale `true` y el denominador de una función racional no se puede factorizar, `integrate` devuelve la integral como una suma respecto de las raíces desconocidas del denominador.

  Por ejemplo, dándole a `integrate_use_rootsof` el valor `false`, `integrate` devuelve la integral no resuelta de la función racional en forma nominal:

      (%i1) integrate_use_rootsof: false$
      (%i2) integrate (1/(1+x+x^5), x);
              /  2
              [ x  - 4 x + 5
              I ------------ dx                            2 x + 1
              ]  3    2                2            5 atan(-------)
              / x  - x  + 1       log(x  + x + 1)          sqrt(3)
      (%o2)   ----------------- - --------------- + ---------------
                      7                 14             7 sqrt(3)

  Si ahora se le da a la variable el valor `true`, la parte no resuelta de la integral se expresa como una suma cuyos sumandos dependen de las raíces del denominador de la función racional:

      (%i3) integrate_use_rootsof: true$
      (%i4) integrate (1/(1+x+x^5), x);
            ====        2
            \       (%r4  - 4 %r4 + 5) log(x - %r4)
             >      -------------------------------
            /                    2
            ====            3 %r4  - 2 %r4
                              3      2
            %r4 in rootsof(%r4  - %r4  + 1, %r4)
      (%o4) ----------------------------------------------------------
                     7

                                                             2 x + 1
                                         2            5 atan(-------)
                                    log(x  + x + 1)          sqrt(3)
                                  - --------------- + ---------------
                                          14             7 sqrt(3)

  Alternativamente, el usuario puede calcular las raíces del denominador separadamente y luego representar el integrando en función de dichas raíces, como por ejemplo `1/((x - a)*(x - b)*(x - c))` o `1/((x^2 - (a+b)*x + a*b)*(x - c))` si el denominador es un polinomio de tercer grado. En algunos casos, esto ayudará a Maxima mejorar sus resultados.

Función: ldefint (expr, x, a, b)

  Calcula la integral definida de expr utilizando `limit` tras el cálculo de la integral indefinida de expr respecto a x en los extremos de integración b y a. Si no consigue calcular la integral definida, `ldefint` devuelve una expresión con los límites en forma nominal.

  La función `integrate` no llama a `ldefint`, de modo que la ejecución de `ldefint (expr, x, a, b)` puede dar un resultado diferente que `integrate (expr, x, a, b)`. La función `ldefint` siempre utiliza el mismo método para calcular la integral definida, mientras que `integrate` puede hacer uso de varias heurísticas y reconocer así casos especiales.

Función: residue (expr, z, z_0)

  Calcula el residuo en el plano complejo de la expresión expr cuando la variable z toma el valor z_0. El residuo es el coeficiente de `(z - z_0)^(-1)` en el desarrollo de Laurent de expr.

      (%i1) residue (s/(s**2+a**2), s, a*%i);
                                      1
      (%o1)                           -
                                      2
      (%i2) residue (sin(a*x)/x**4, x, 0);
                                       3
                                      a
      (%o2)                         - --
                                      6

Función: risch (expr, x)

  Integra expr respecto de x utilizando el caso trascendental del algoritmo de Risch. El caso algebraico del algoritmo de Risch no se ha implementado. Este método trata los casos de exponenciales y logaritmos anidados que no resuelve el procedimiento principal de `integrate`. La función `integrate` llamará automáticamente a `risch` si se presentan estos casos.

  Si la variable `erfflag` vale `false`, evita que `risch` introduzca la función `erf` en la respuesta si ésta no estaba presente previamente en el integrando.

      (%i1) risch (x^2*erf(x), x);
                                                              2
                   3                      2                - x
              %pi x  erf(x) + (sqrt(%pi) x  + sqrt(%pi)) %e
      (%o1)   -------------------------------------------------
                                    3 %pi
      (%i2) diff(%, x), ratsimp;
                                   2
      (%o2)                       x  erf(x)

Función: tldefint (expr, x, a, b)

  Equivale a `ldefint` cuando `tlimswitch` vale `true`.

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