Espaço-Tempo Perturbado: integral Definida

Computação científica com Python: Integração numérica.

Atualização: 27/05/2011. O programa agora está do google code e a página do projeto é: http://code.google.com/p/pyintegral/

Caso tenha problemas de visualização, veja esse texto completo em: http://docs.google.com/View?id=dgtpbnvj_3f74xftcz

Nesse exemplo será mostrado com mais detalhes uma forma simples de resolver integrais definidas,no intervalo [a,b], de uma função com uma variável usando python.

O programa final ficou com a seguinte aparência:

Na figura anterior, nos espaços após a, b e dx insere-se respectivamente, o limite inferior (a) e superior (b) da integral e o valor de $\Delta x$ (dx), que é o passo de integração.
No espaço após y(x) escreve-se a função a ser integrada, lembrando que x tem que ser escrito com letra minuscula.
Exe:

2*cos(x)

expoente é escrito como x**2.0 (x²). Lembrete, ângulos são definidos em radianos.

Clica-se em resultado e o valor da integração irá aparecer.

Se você não tem o Python instalado e é usuário de Windows mas deseja rodar esse programa, clique aqui para baixar o instalador. Execute-o e siga os passos de instalação. Esse programa rodará como qualquer outro programa desenvolvido para windows. Para executa-lo vá no menu iniciar e procure por Integral Soma Retangulos, como é mostrado na figura abaixo:

Para baixar o código fonte clique aqui.

Teoria:

A integral definida de uma função f(x)

pode ser compreendida como o cálculo da área

abaixo da curva.

A ideia aqui é que a área

pode ser subdividida em

áreas de largura $\Delta x$ e altura f(x)

, com:

$\Delta x=\frac{b-a}{N}$ . (1)

No limite em que $N\rightarrow \infty$ , a integral de f(x)

pode ser escrita como:

$\int^{b}_{a}f(x)=\lim_{n \rightarrow \infty } \sum_{i=1}^{N}} {f(x)\Delta x}$ . (2)

No programa descrito aqui a aproximação será a seguinte, ao invés de fazer uma soma infinita, será fornecido um $\Delta x \ll 1$ e o intervalo de integração será subdividido de forma que:

$N=\frac{b-a}{\Delta x}$ , (3)

Ou seja, não teremos nesse caso infinitos retângulos infinitesimais, mas sim a soma finita de

retângulos. Quanto menor for o $\Delta x$ usado mais precisa será a integração, porém o custo computacional se tornará cada vez maior.

Nesse caso, o erro associado a integração ocorre porque $\Delta x$ poderá ser grande e os retângulos não se ajustarem corretamente a área abaixo da curva, como é apresentado na figura abaixo.

Aqui não será detalhado o tratamento de erros no método de integração. O objetivo principal será o de mostrar como é relativamente simples fazer o tratamento computacional desse problema usando Python.

Escrevendo o programa:

Aqui será utilizada a função "arange" do módulo numpy (numerical python). Para Baixar esse módulo e obter mais detalhes clique aqui e vá a página do projeto.

Primeiramente importa-se o modulo.
Abaixo será criado um lista contendo N elementos no intervalo [a,b] de largura dx.

from numpy import arange

a = float(raw_input('Entre com o limite inferior: '))
b = float(raw_input('Entre com o limite superior: '))
dx = float(raw_input('Entre com o valor de delta x: '))

s = arange(a,b,dx)#Cria-se a lista contendo N elementos no 
                  #intervalo [a,b] de largura dx

Para obter a integral vamos usar a função map, sum e lambda.

A função map aplica a todos os valores contidos em uma lista uma função qualquer e retornando uma nova lista com os resultados obtidos.

Exe 1:

#Defini-se a função de interesse

def f(x): #f(x) = x^{2}
return x**2.0

y = map(f,arange(1,10,1))

print y

>>
[1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0, 81.0]

A função sum irá retornar a soma de todas os valores de uma lista.

Exe:

y0 = sum(y)

print y0
>>
285.0

Já com a função lambda é possível construir uma função da seguinte forma:

f = lambda x: x**2.0

que é equivalente a:

def f(x):
return x**2.0

Finalmente vamos definir a função de integração. Aqui será utilizado também o módulo math, que contém uma série de funções matemáticas, como cos(x).

from numpy import  arange
from math import  *

def IntegralSimples(func,a,b,dx):
'''Funcao integradora'''
return  sum(map(lambda x: func(x)*dx,arange(a,b,dx)))

a = float(raw_input('Entre com o limite inferior'))

b = float(raw_input('Entre com o limite superior'))

dx = float(raw_input('Entre com o valor de delta x'))

fx = raw_input('Entre com a funcao a ser integrada')

def f(x):
return eval(fx)

resultado= IntegralSimples(f,a,b,dx)

print 'Valor da integral: ', resultado

Veja que com apenas duas linhas de comando temos uma função que resolve numéricamente integrais definidas.
Também foi utilizada a função eval, que é utilizada para avaliar expressões Python válidas armazenadas numa string.

Outra coisa a destacar no programa anterior é que a variável fx na função f(x) foi mascarada. Em Python pode-se definir variáveis globais e locais. Porém, algo interessante aqui é que, como a variável fx foi definida antes e fora da função f(x), a mesma é reconhecida dentro da função. Esse é o recurso de mascarar uma variável. Mas é possível criar dentro de funções variáveis locais com o mesmo nome que variáveis fora da função e que não estão conectadas.
Exe:

>> x = 3

>> print 'X fora: ', x
x fora: 3
>>def f():
x = 6
print 'X local: ' x
>> f()
x local: 6
>>print 'X fora: ', x
x fora: 3

Em geral não se recomenda o uso de variáveis globais ou a técnica de mascarar uma variável. Pois será muito mais complicado debugar o programa.
Para resolver esse problema, basta reescrever o programa usando o paradigma da programação orientada a objetos (que não vou entrar em detalhes nesse momento). Nesse caso o código ficará assim:

from numpy import  arange
from math import  *

class MYIntegral():
  
    def __init__(self,fx):
        self.fx = fx

    def IntegralSimples(self,a,b,dx):
        '''Funcao integradora'''
        return  sum(map(lambda x: self.f(x)*dx,arange(a,b,dx)))
  
    def f(self,x):
        return eval(self.fx)


a = float(raw_input('Entre com o limite inferior: '))

b = float(raw_input('Entre com o limite superior: '))

dx = float(raw_input('Entre com o valor de delta x: '))

fx = raw_input('Entre com a funcao a ser integrada: ')


obj = MYIntegral(fx)

resultado = obj.IntegralSimples(a,b,dx)

print 'Valor da integral: ', resultado

Para baixar o código fonte já com a GUI inculida clique aqui.

Até a próxima.
Esse material também está disponível no google docs em: http://docs.google.com/View?id=dgtpbnvj_3f74xftcz