Calculando integrales con Python y SymPy

Comentarios

Código fuente

Las integrales son unos de los conceptos básicos en la formación matemática de un ingeniero, es en términos básicos la operación inversa de la derivación. Pero, además del concepto puramente matemático, las integrales tienen múltiples interpretaciones geométricas y físicas.

En un curso ordinario de cálculo se nos enseñan métodos para resolver de forma analítica funciones que sean integrables. Por ejemplo todos sabemos que la integral de una función constante será:

$$ \int a\,dx = ax + C $$

Y lo sabemos porque nos hemos aprendido reglas básicas de integración y por supuesto a indentificar el tipo de función. Actualmente existen paquetes de álgebra simbólica que son capaces de realizar esta tarea: identificar el caso que se tiene y aplicar métodos computacionales, hasta cierto grado complejos, para determinar la solución.

Y claro, SymPy es uno de esos sistemas de álgebra computacional (CAS), en el que solo necesitamos escribir nuestra función a integrar, utilizar por ahí alguna rutina y obtener un resultado rápidamente. Pero claro, para ello debemos aprender mínimamente la sintaxis y eso es justo lo que veremos enseguida.

Integrales simples

Vamos a ver cómo resolver integrales simples indefinidas, si, de esas que vemos en un primer curso. Para resolverlas tendremos que utilizar la función integrate. Por ejemplo se tiene la siguiente función $f(x)=x^2-3x+2 $.

Como primer paso debemos importar lo que necesitaremos del paquete SymPy:

In [1]:
from sympy import integrate, init_printing
from sympy.abc import x
init_printing(use_latex="mathjax")

Del módulo abc importamos la variable simbólica x e integrate para resolver nuestra integral. Ahora, podemos guardar la función a integrar en una variable o bien pasarla directamente como argumento:

In [2]:
f = x**2 - 3*x + 2
integrate(f)
Out[2]:
$$\frac{x^{3}}{3} - \frac{3 x^{2}}{2} + 2 x$$

En este caso no hemos tenido incovenientes, porque en la expresión a integrar sólo existe una variable simbólica, pero si la expresión tuviese más de una, habría que especificar de manera explícita la variable respecto a la cual se integra, de lo contrario Python nos mostrará un error:

In [3]:
from sympy.abc import a,b,c
f = a*x**2+b*x+c
integrate(f)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-3-476839d3c49d> in <module>()
      1 from sympy.abc import a,b,c
      2 f = a*x**2+b*x+c
----> 3 integrate(f)

~\Anaconda3\lib\site-packages\sympy\integrals\integrals.py in integrate(*args, **kwargs)
   1289     risch = kwargs.pop('risch', None)
   1290     manual = kwargs.pop('manual', None)
-> 1291     integral = Integral(*args, **kwargs)
   1292 
   1293     if isinstance(integral, Integral):

~\Anaconda3\lib\site-packages\sympy\integrals\integrals.py in __new__(cls, function, *symbols, **assumptions)
     73             return function._eval_Integral(*symbols, **assumptions)
     74 
---> 75         obj = AddWithLimits.__new__(cls, function, *symbols, **assumptions)
     76         return obj
     77 

~\Anaconda3\lib\site-packages\sympy\concrete\expr_with_limits.py in __new__(cls, function, *symbols, **assumptions)
    375                     " more than one free symbol, an integration variable should"
    376                     " be supplied explicitly e.g., integrate(f(x, y), x)"
--> 377                     % function)
    378             limits, orientation = [Tuple(s) for s in free], 1
    379 

ValueError:  specify dummy variables for a*x**2 + b*x + c. If the integrand contains more than one free symbol, an integration variable should be supplied explicitly e.g., integrate(f(x, y), x)

Pues eso, si intentamos integrar la función $f(x)=ax^2+bx+c$ sin especificar la variable de integración, Python nos mandará un error que es bastante sugerente al respecto. Así, lo correcto sería:

In [4]:
integrate(f, x)
Out[4]:
$$\frac{a x^{3}}{3} + \frac{b x^{2}}{2} + c x$$

Integrales definidas

Una integral definida usualmente se utiliza para calcular el área bajo la curva de una función en un intervalo finito. En SymPy, para calcular una integral definida se utiliza la función integrate, considerando el hecho que deben adicionarse los límites de evaluación mediante la sintaxis:

integrate(fun, (var, a, b))

Donde fun es la función, var la variable respecto a la cual se integra, a el límite inferior y b el límite superior.

Para ejemplificar vamos a resolver la siguiente integral definida:

$$ \int_0^{\frac{\pi}{2}} \cos x \,\, dx $$
In [5]:
from sympy import cos,pi

integrate(cos(x), (x,0,pi/2.0))
Out[5]:
$$1$$

Otro ejemplo:

$$ \int_0^5 x \, dx $$
In [6]:
integrate(x, (x,0,5))
Out[6]:
$$\frac{25}{2}$$

Integrales múltiples

Ahora vamos a resolver integrales dobles (la sintaxis/metodología de resolución que se revisará aplica para cualquier integral múltiple). Por ejemplo vamos a resolver la integral dada por:

$$ \int_a^b \int_c^d \, dy \, dx $$

Recuerde que este tipo de integrales múltiples se resuelven de forma iterada, yendo de dentro hacia afuera, es decir, para la integral anterior se procedería:

$$ I_1 = \int_c^d \, dy \qquad \rightarrow \qquad I = \int_a^b \, I_1 \, dx $$

En Python/SymPy hacemos exactamente lo mismo:

In [9]:
from sympy.abc import x,y,z,a,b,c,d
from sympy import simplify
In [10]:
I1 = integrate(1, (y,c,d))
simplify( integrate(I1, (x,a,b) ) )
Out[10]:
$$\left(a - b\right) \left(c - d\right)$$

Comentarios

Comments powered by Disqus