# Integración con MAXIMA

## Integración indefinida

### Función integrate

 
Maxima tiene varias rutinas para el cálculo de primitivas de una función, la  mayoría de ellas se consigue mediante el comando

    [→ integrate

Existe un paquete de funciones de funciones no especificadas y sus derivadas, se trata del paquete

    [→ antid

que se puede cargar en memoria con el comando load("antid")

Finalmente, tambiébn es posible  realizar integración numérica.

 
FUNCIÓN: integrate

El comando integrate calcula simbólicamente la primitiva de una función. Se utiliza tanto para integrales indefinidas como definidas.

Para cálculo de primitivas (integral indefinida) se usa la expresión

      [→ integrate(expr,x)


donde

    - expr: expresión simbólica que contiene la función a integrar.

    - x:       variable  respecto de la cual vamos a calcular la primitiva

 
EJEMPLO: Vamos a calcular la integral de la función logaritmo.

En MAXIMA la función logaritmo viene dada por la instrucción 

    log(x)

por claridad y aunque no es necesario, definirermos una variable, f, para contener a la función logaritmo y 
usaremos otra variable, F, que contendrá a la primitiva de f.

f: log(x);
'integrate(f,x);
F:integrate(f,x);

 
Podemos comprobar que la variable F contiene una primitiva de f,  para ello usamos la función 

    [→ diff(expr,x)

que calcula la derivada de  la función indicada en expr, respecto de la variable x

diff(F,x);

Con este ejemplo comprobamos que MAXIMA no incluye la constante de integración.

 
También podemos definir la función al estilo usual de MAXIMA, incluyendo la variable en la forma g(x)

g(x):=log(x);

'integrate(g(x),x);
G(x):=integrate(g(x),x)$
G(x);

 
Como en todas las funciones de MAXIMA, también es posible utilizar la función
directamente en la llamada a integrate, sin el uso de variables intermedias

integrate(log(x),x);

integrate(exp(x)*sin(x),x);

 
También es posible utilizar variables distintas a x

integrate(log(r),r);

integrate(log(pepe),pepe);

TIPOS DE INTEGRANDO:

MAXIMA realiza  fácilmente integración de funciones trigonométricas

integrate(sin(3*x)*cos(5*x),x);

'integrate(cos(x)/(1+cos(x)^2),x);
integrate(cos(x)/(1+cos(x)^2),x);

Podemos intentar simplificar la expresión con las funciones correspondientes (Ver menú Simplificar para ver todas las opciones)

trigsimp(%);

Además del cálculo de primitivas de funciones trigonométricas como la anterior, MAXIMA realiza integración de funciones racionales:

Raíces reales simples

'integrate(1/((x-1)*(x+2)),x);
integrate(1/((x-1)*(x+2)),x);

Raíces reales múltiples

'integrate(1/((x-1)^2*(x+3)^3),x);
integrate(1/((x-1)^2*(x+3)^3),x);

Raíces reales y complejas simples

'integrate(1/(x^4-1),x);
integrate(1/(x^4-1),x);

Raíces complejas múltiples

'integrate(1/(x^2+1)^2,x);
integrate(1/(x^2+1)^2,x);

Raíces reales y complejas múltiples

'integrate((2*x+3)/((x-2)^3*(x^2+9)^3),x);
integrate((2*x+3)/((x-2)^3*(x^2+9)^3),x);

Funciones radicales

'integrate(sqrt(x^2+1),x);
integrate(sqrt(x^2+1),x);

Integración por partes

'integrate(x^3*exp(x),x);
integrate(x^3*exp(x),x);

 
Si la función del integrando no tiene primitiva expresable mediante funciones elementales, 
entonces MAXIMA lo dejará indicado.

Supongamos que queremos calcular la siguiente integral

f:exp(-x^2)$
'integrate(f,x);

 
En este caso MAXIMA calcula el valor usando la llamada función  de error.

                          x
                 2     /    - t^2 / 2  
erf(x) = -------- |   e                 dt
               √π   /
                      0

integrate(f,x);

Podemos evitar el uso de la función error, desactivando la variable erflag

erfflag:false;
integrate(f,x);

aunque como veis, no es recomendable, porque tampoco sabéis cuál es la función gamma incompleta.
Así que volvemos a dejar la variable como estaba.

erfflag:true;

 
Para conocer el significado de las funciones empleadas (erf, gamma_incomplete) podemos usar el comando 

    describe(nombre) 

o 

    ? nombre

y la instrucción

    ??

describe(erf);

 
Si tampoco encuentra la primitiva, lo dejará indicado

'integrate(exp(x^3+x),x);
integrate(exp(x^3+x),x);

### Cambio de Variable

 
CAMBIO DE VARIABLE:

Podemos realizar cambios de variable, que deben expresarse mediante una ecuación del tipo

    f(x,t)=0

con la instrucción

    changevar(expr,f(x,t),t,x)

donde 

    expr: es la expresión a la que vamos a hacer el cambio de variable.
    f(x,t)=0: es la ecuación que relaciona la variable nueva "t" con la variable antigua "x",
    t: nueva variable
    x: antigua variable


por ejemplo, si queremos  calcular una primitiva de la función

f:1/(exp(x)+exp(-x));

 
es decir si queremos calcular 

s1:'integrate(f,x);

 
NOTA: Por comodidad se ha definido una nueva variable MAXIMA, s1, 
que contiene la expresión anterior, con el fin de utilizarla posteriormente.

  
Para calcular esta primitiva podemos hacer el cambio de variable

 t = exp(x)

que si lo expresamos como ecuación f(x,t)=0, sería

 t - exp(x) =0

En este caso
                                                                               1
dt = exp(x) dx ==> dx = exp(x) dt  ==>   dx = ------ dt
                                                                               t

Para hacer este cambio de variable con MAXIMA, usaremos el comando changevar  como sigue:

  [→ changevar(s1, t-exp(x),t,x);

El primer argumento contiene la integral, el segundo es la ecuación que determina el cambio de variable, 
el tercero es la variable nueva y el cuarto es la variable antigua.

s2: changevar(s1,t-exp(x),t,x);

 
que es una integral inmediata que podemos calcular directamente a mano

    arctan(t)

o con MAXIMA, teniendo en cuenta que la variable de integración es ahora t.

También es posible evaluar la integral directamente con la opción "nouns" dentro del comando ev
 
    ev(s2,nouns)

s2 contiene la expresión de la integral

F:ev(s2,nouns);

 
Después deshacer el cambio intercambiando las variables antigua y nueva

  [→ F,t=exp(x)

F,t=exp(x);

 
Comprobamos el resultado

diff(atan(exp(x)),x);

El proceso completo se incluye a continuación:

kill(all)$                                                 /* Limpiar memoria */
f:1/(exp(x)+exp(-x))$                           /* Definimos la función del integrando */
s1:'integrate(f,x);                                  /* Definimos la función integral que queremos calcular */
s2: changevar(s1,t-exp(x),t,x);           /* Realizamos el cambio de variable */
F:ev(s2,nouns);                                    /* Evaluamos la integral con el cambio de variable */
F,t=exp(x);                                            /*  Deshacemos el cambio de variable */

 
Maxima trata de resolver la integral directamente, aplicando los cambios de variable necesarios, por ejemplo, para la función del
ejemplo anterior, podíamos haber integrado directamente sin realizar el cambio de variable

f:1/(exp(x)+exp(-x));
'integrate(f,x);
integrate(f,x);

Aunque la expresión obtenida es distinta, se puede comprobar que ambas son primitivas de la función,
simplemente caculando la derivada

diff(atan(exp(x)),x);
diff(-atan(-exp(x)),x);

Además se puede comprobar también que se diferencian en una constante

f1(x):=atan(exp(x));
f2(x):=-atan(exp(-x));
f1(2.0)-f2(2.0);
f1(3.0)-f2(3.0);

que no es otra que π/2

float(%pi/2);

 
Sin embargo, en ocasiones, MAXIMA necesita que le echemos una mano para poder encontrar la primitiva de una función.
Vamos a buscar la primitiva de la siguiente función

g: cos(x)/sqrt(1+tan(x)^2);
'integrate(g,x);
integrate(g,x);

 
Vemos que en la solución de MAXIMA aparece la unidad imaginaria %i. 

Sin embargo, si realizamos el cambio de variable general para este tipo de integrales trigonométricas

t = tan(x) 

Usando la ecuación al estilo MAXIMA

t-tan(x) = 0

 
Definimos la integral, de forma simbólica

GdeX : 'integrate(g,x);

 
Hacemos el cambio de variable en la integral

GdeT:changevar(GS,t-tan(x),t,x);

 
Calculamos la primitiva

G : ev(GdeT,nouns);

 
Deshacemos el cambio:

GdeX: G,t=tan(x);

y simplificamos 

trigreduce(GdeX);

 
Solución más acorde con lo esperado.

### Dudas

Algunas veces MAXIMA solicitará información sobre las variables 
utilizadas en el cambio:

 f:sqrt(x^3)/(sqrt(x)+1);
FX:'integrate(f,x);

Hacemos el cambio de variable:

sqrt(x) = t ==> x=t^2 

Por tanto tendríamos 

dx = 2t dt

FS:changevar(FX,t-sqrt(x),t,x);                                                           /* Cambio de variable t = √x  */
ev(FS,nouns);                                                                                       /* Evaluamos la integral, si MAXIMA necesita más información, preguntará sobre ella */
ev(FS,nouns),t=sqrt(x);                                                                        /* Deshacemos el cambio */

 
Pero algunas veces el cambio de variable no le sirve para nada a MAXIMA

f:(x+sqrt(x+1)^3)/((x-1)*sqrt(x+1));                      /* Definimos la función del integrando */
FX:'integrate(f,x);                                                   /* Definimos la función primitiva, que depende de x */
FS:changevar(FX,x+1-t^2,t,x);                            /* Cambiamos la variable con x+1 = t^2 */
ev(FS,nouns);                                                       /* Intentamos calcular la primitiva */

 
Podemos intentar resolver el problema usando el comando asume

kill(all)$                                                                   /* Borrado general de memoria */
assume(t>0);                                                         /* A partir de aquí, consideramos que t es una variable >0 */
f:(x+sqrt(x+1)^3)/((x-1)*sqrt(x+1));                      /* Definimos la función del integrando */
FX:'integrate(f,x);                                                  /* Definimos la función primitiva, que depende de x */
FS:changevar(FX,x+1-t^2,t,x);                           /* Cambiamos la variable con x+1 = t^2 */
F:ev(FS,nouns);                                                    /*  Evaluamos la integral respecto de t */
F,t=sqrt(x+1);                                                         /* Deshacemos el cambio de variable */

forget(t>0);                                                           /* A partir de aquí, t vuelve a ser una variable  general */

## Integral de Riemann: Integrales definidas

 
FUNCIÓN: integrate

El comando integrate también se utiliza para calcular integrales definidas si incluimos dos argumentos adicionales, 
que corresponden a los extremos del intervalo. La forma de utilizar el comando es el siguiente

    [ → ]integrate(expr,x,a,b)

donde:

     - expr:   expresión simbólica
     - x:         variable  respecto de la cual vamos a calcular la primitiva
     - a:        extremo inferior del intervalo
     - b:        extremo superior del intervalo

 
EJEMPLO: Calcula la siguiente integral definida
                1
             /
             [                                    
             I  x*exp(x) dx
             ]
             /
              0

'integrate(x*exp(x),x,0,1);

integrate(x*exp(x),x,0,1);

 
La instrucción 

defint(expr,x,a,b)

es una alternativa a integrate para las integrales definidas.

defint(x*exp(x),x,0,1);

## Integrales dependientes de parámetros

kill(all)$
f : exp(-a*x);
F : 'integrate(f,x);
ev(F,nouns);

 
En la integrales pueden aparecer parámetros en la función

Tanto para integrales indefinidas

f:exp(a*x);
F:'integrate(f,x);
ev(F,nouns);

 
como definidas:

FD:'integrate(f,x,0,1);
ev(FD,nouns);

 
En este caso, también puede haber parámetros en los extremos de integración

FD:'integrate(f,x,0,b);
ev(FD,nouns);

Incluso pueden aparecer funciones en los extremos de integración

FD:'integrate(sin(t),t,x^2,x^3);
FdX:ev(FD,nouns);

Regla de la Cadena:

diff(FD,x);

Si el valor de la primitiva depende de parámetros y MAXIMA lo necesita, preguntará por ellos

F:'integrate(1/x**a,x);
ev(F,nouns);

Preguntará todo lo que necesite

F:'integrate(1/x,x,a,b);
ev(F,nouns);

Para evitar interrupciones en el flujo del programa, siempre podemos utilizar la instrucción 

assume 

para evitar cuestiones intermedias.

kill(all)$
assume(a>1);
F:'integrate(1/x**a,x);
ev(F,nouns);

Como antes, usamos forget para eliminar la restricción del parámetro a

forget(a>1);
F:'integrate(1/x**a,x);
ev(F,nouns);

## Integración impropia

### Integrales impropias de primera especie

En MAXIMA también es posible utilizar límites ∞ (inf) y -∞ (minf) 
para realizar el cálculo de integrales impropias de primera especie.

EJEMPLO: Calcula la siguiente integral impropia de primera especie

   ∞
   /
  |                                        
  |       exp(-x) dx
  |
 /   0

Para ello hay que usar el límite inf como extremo superior.

F:'integrate(exp(-x),x,0,inf);

ev(F,nouns);

EJEMPLO: Calcula la siguiente integral impropia de primera especie

   0
   /
  |                                        
  |       √(exp(x)) dx
  |
 /   -∞

Para ello hay que usar minf como extremo inferior

F:'integrate(sqrt(exp(x)),x,minf,0);

ev(F,nouns);

EJEMPLO: Calcula la siguiente integral impropia de primera especie

    ∞
   /
  |               1                    
  |       ---------------------- dx
  |         exp(x) + exp(-x)
 /   -∞

Para ello hay que usar inf y minf como extremos de integración

F:'integrate(1/(exp(x)+exp(-x)),x,minf,inf);

ev(F,nouns);

EJEMPLO: Calcula la siguiente integral impropia de primera especie

    ∞
   /
  |                              
  |       x    dx
  |         
 /   -∞

Para ello hay que usar inf y minf como extremos de integración

F:'integrate(x,x,minf,inf);

ev(F,nouns);

Observamos cómo MAXIMA indica que el resultado es el Valor Principal, aunque no nos informe de ello.

Recordemos que para comprobar si una integral de primera especie sobre toda la recta real (-∞,∞)  es convergente,
debemos integrar sobre cada tramo. De esta forma la forma correcta de calcular la integral anterior es:

F1:'integrate(x,x,0,inf);
F2:'integrate(x,x,minf,0);

y comprobamos su divergencia.

ev(F1,nouns);

ev(F2,nouns);

### Integrales impropias de segunda especie

Podemos calcular integrales impropias de segunda especie directamente

F:'integrate(1/sqrt(4-x^2),x,0,2);

ev(F,nouns);

F:'integrate(log(x)/sqrt(x),x,0,1);

ev(F,nouns);

Variables opcional: 

    intanalysis

Si esta variable toma el valor true (que es el valor por defecto) entonces, la función integrate trata de
encontrar las discontinuidades del integrando dentro del intervalo de integración. 

Comprobamos su valor

intanalysis;

EJEMPLO: Calcula la siguiente integral

     3 
    /
   |           1                        
   |       --------  dx
   |        (x-1)^2
  /   
0

f:1/(x-1)^2;
F:'integrate(f,x,0,3);

Notar que hay una discontinuidad en x=1, ya que anula el denominador, 
y dicha discontinuidad se encuentra en el intervalo de integración,
por tanto al realizar el cálculo correspondiente, obtendremos un error ya que 
la integral es divergente.

ev(F,nouns);

Si esta variable toma el valor false, entonces la integración se realiza sin tener en 
cuenta las discontinuidades y se obtiene el Valor Principal de la integral.

intanalysis:false$
ev(F,nouns);

Para evitar confusiones sobre la convergencia, es mejor dejar esta opción como true

intanalysis:true;

ev(F,nouns);

EJEMPLO: Vamos a ver otro ejemplo. Calcularemos la siguiente integral con ambos valores (true y false)

   1   
   /
   [       1
   I  ----------- dx
   ]      x^(1/3)
   /
 -1

f:1/x^(1/3);
F:'integrate(f,x,-1,1);

Usando true

intanalysis:true;
ev(F,nouns);

Y usando false

intanalysis:false;
ev(F,nouns);

## Usando el menú

Es posible realizar integración haciendo uso de las opciones de menú:

   Análisis --> Integrar

Se abre un cuadro de diálogo que nos permite incluir, la expresión de la función a integrar, 
la variable de integración y decidir si es indefinida o definida; en este último caso se incluyen 
los extremos de integración y el método de cálculo en caso de aproximación numérica.

Usa el menú ahora para calcular la integral de la función

    exp(a*x)*sin(b*x)

en el intervalo [0,π] y donde a y b son número reales.