1) Dê a fórmula da integral de no intervalo via método de Simpson.

Transcrição

1 Instruções Esta prova é um longo exercício. Leia todas as questões antes de começar a resolver. Algumas funções úteis já estão incluídas na prova. Explique a sua solução em caixas de texto ou numa folha de prova. Interpolação e integrais O objetivo deste exercício é fazer o gráfico de primitivas de funções, numericamente. Vamos enfatizar também a necessidade de controle sobre o erro resultante dos métodos numéricos, para poder dar uma resposta mais completa ao traçar a primitiva. f [a, b] 1) Dê a fórmula da integral de no intervalo via método de Simpson. 2) Integrais passo a passo Para fazer o gráfico de uma primitiva, precisamos calcular a integral x f (t) dt para vários valores de x. a Escreva a função primitiva que, dado um passo, retorna um vetor com todas as integrais numéricas tais que a a + nh b h. Use a fórmula de Simpson. a+nh a f (t) dt para os n In [1]: %pylab inline Populating the interactive namespace from numpy and matplotlib In [1]: def primitiva(f,a,b,h): y = [] return array(y)

2 Teste a sua função. Sugestão: use funções cuja primitiva você conhece! In [ ]: 3) Erros Faça gráficos para mostrar como o erro de integração (diferença entre a primitiva numérica e a primitiva analítica) evolui, conforme: 1. O número de pontos utilizados aumenta 2. O tamanho do intervalo de integração aumenta. Tente achar funções cujos gráficos dos erros tenham comportamentos diferentes, e escolha 2 ou 3 funções representativas (para cada item acima). In [ ]: 4) Interpolação 4) Interpolação A função primitiva retorna vários pontos que podem ser interpolados. Até aqui, os gráficos foram feitos de forma "linear por partes" (porque é assim que plot(... ) funciona!), e usando passos relativamente pequenos (provavelmente o que você fez na questão 3 tem passos pequenos). Vamos continuar nosso objetivo de chamar f o menos possível! Usando um passo relativamente grande, faça um gráfico da integral usando interpolação de Lagrange. Compare o erro obtido pela interpolação de Lagrange com o que você obteria por interpolação linear por partes para o mesmo passo.

3 In [10]: def baricentrica(x,y): """ Calcula o polinômio interpolador de Lagrange nos pontos $(x_i, y_i)$ usando a forma baricêntrica. """ w = [1/(prod([xi - xj for xj in x if xj!= xi])) for xi in x] def P(z): num = 0 den = 0 for i in range(len(x)): t = w[i]/(z - x[i]) den += t num += t * y[i] return num/den return P In [11]: from scipy.interpolate import interp1d # Para calcular interpolação linear por partes (e spl ines, se você quiser)

4 In [12]: # Exemplo de gráfico que você pode fazer: # Veja que o python dá uns erros, porque a fórmula baricêntrica produz "not-a-number" se voc ê mandar calcular num nó de interpolação. # No gráfico, isso desaparace, em geral. -c:8: RuntimeWarning: divide by zero encountered in true_divide -c:10: RuntimeWarning: invalid value encountered in multiply Out[12]: <matplotlib.legend.legend at 0x7f368d9f58d0> /usr/lib64/python3.3/site-packages/matplotlib/scale.py:93: RuntimeWarning: invalid value enco untered in less_equal mask = a <= 0.0 5) Pontos de Chebyshev Usar pontos de Chebyshev é melhor para calcular o polinômio interpolador: os erros nas bordas são menores, e também há menos propagação de erro. Por outro lado, a função primitiva terá que ser modificada para, em vez de um simples passo, receber o vetor de todos os pontos xs onde você quer calcular a primitiva. h

5 In [14]: def primitiva(f,xs): y = [0] return y Novamente, teste a sua função em casos simples antes de continuar! Veja que você não é obrigado a usar pontos de Chebyshev para os testes. In [ ]: 6) Repita as questões 3 e 4 para a nova versão da primitiva. Agora, use pontos de Chebyshev para interpolar. Abaixo estão repetidos os enunciados das questões 3 e ) Erros Faça gráficos para mostrar como o erro da primitiva numérica com relação à primitiva real evolui, conforme: 1. O número de pontos utilizados aumenta 2. O tamanho do intervalo de integração aumenta. Tente achar funções cujos gráficos dos erros tenham comportamentos diferentes, e escolha 2 ou 3 funções representativas (para cada item acima). 6.4) Interpolação A função primitiva retorna vários pontos que podem ser interpolados. Até aqui, os gráficos foram feitos de forma "linear por partes" (porque é assim que plot(... ) funciona), e usando passos relativamente pequenos (provavelmente o que você fez na questão 3 tem passos pequenos). Vamos continuar nosso objetivo de chamar f o menos possível! Usando um passo relativamente grande, faça um gráfico da integral usando interpolação de Lagrange. Compare o erro obtido pela interpolação de Lagrange com o que você obteria por interpolação linear por partes para o mesmo passo.

6 In [18]: def chebyshev_nodes(a,b,n): """ Calcula os (n+1) pontos de Chebyshev para interpolação de ordem n """ ang = pi*arange(n+1)/n x = (a+b)/2 + (b-a)*cos(ang)/2 return array(list(reversed(x))) In [ ]: 7) Controle do erro Lembre-se da fórmula adaptativa para o método de Simpson: ao dividir um intervalo em dois, e calcular a integral de duas formas diferentes, temos uma estimativa do erro cometido: I fina I fina I grossa I f Use esta fórmula para retornar uma estimativa do erro, no caso de pontos uniformemente espaçados. In [26]: def primitiva(f,a,b,h): y = [0] err = [0] return array(y), array(err) Agora, faça um gráfico com a primitiva numérica e a "faixa de erro" da mesma. A faixa de erro corresponde aos limites máximos e y ± err mínimos onde a primitiva "de verdade" pode passar, dados os valores numéricos e os erros calculados. (Ou seja,.) Use bem poucos pontos para poder verificar se o gráfico da primitiva analítica realmente está dentro dos limites indicados. In [ ]:

7 8) Erro e interpolação Em geral, o gráfico da função vai "cair fora" da interpolação linear por partes. Refaça as estimativas de erro, agora usando interpolação de Lagrange três vezes: para a primitiva numérica, e para as duas estimativas de erro em volta da primitiva. Sugestões: faça o gráfico da diferença entre as primitivas numéricas que você calculou e a primitiva "verdadeira". In [30]: Out[30]: # Um exemplo de gráfico <matplotlib.legend.legend at 0x7f368dfe6b90>

8 9) Métodos adaptativos Adapte o método de cálculo da integral via Simpson adaptativo para que ele retorne os diversos pontos calculados: x [ a k, b k ] [ a k, b k ] as coordenadas dos pontos usados como extremos de intervalos, as integrais nos diferentes intervalos, as estimativas dos erros em cada um dos intervalos. Use isso para passar um polinômio interpolador e comparar com a primitiva teórica. Dica: existe uma função no ipython chamada cumsum que retorna as somas acumuladas de um vetor. Essa função será muito útil para transformar as integrais "finas" (que você calcular em cada intervalo I k ) na primitiva numérica. É mais simples fazer isso fora da função simpson_adaptativo. Note que os pontos vão estar "aleatoriamente" distribuídos no seu intervalo. Será que esta distribuição é melhor ou pior (do ponto de vista da interpolação de Lagrange) do que a distribuição uniforme? E a de Chebyshev? In [31]: def simpson_adaptativo(f, a,b, tol=1e-6): h = (b-a) m = a + h/2. fa = f(a) fb = f(b) fm = f(m) Igrossa = h*(fa + 4*fm + fb)/6 Ifina = h*(fa + 4*f((a+m)/2) + 2*fm + 4*f((m+b)/2) + fb)/12 if 2*abs(Igrossa - Ifina)/15 < tol: return Ifina else: esquerda = simpson_adaptativo(f, a,m, tol/2) direita = simpson_adaptativo(f, m,b, tol/2) return esquerda+direita

9 In [33]: # Um exemplo de gráfico print('número de intervalos necessários: {}'.format(len(xs))) Número de intervalos necessários: 27 10) Conferindo tudo Se tudo deu certo, você conseguirá calcular uma primitiva da exponencial no intervalo [ 1, 3] [0, 3] [ 1, 0] f com um erro menor do que 10 6 nos pontos de interpolação e essencialmente os mesmos no intervalo. No início do intervalo, em, devido à oscilação do polinômio interpolador de Lagrange, o resultado não é tão bom. Mas note que você calculou a apenas em 27 intervalos.

10 In [34]: # Existe uma solução para simpson_adaptativo cujo resultado pode ser usado da seguinte for ma: xs, integrais, estim_err = simpson_adaptativo(f,a,b) xs = array([a] + xs) primitiva = cumsum(array([0] + pf)) estim_err_primitiva = cumsum(array([0] + pf_err)) # Interpolação # Gráficos figure(figsize=(15,5)) subplot(1,2,1) legend(loc=0) subplot(1,2,2) legend(loc=0) print('número de intervalos necessários: {}'.format(len(xs))) Número de intervalos necessários: 27

11 11) Acertando as bordas Você já deve imaginar qual é esta questão: use mínimos quadrados para que o polinômio interpolador de Lagrange tenha menos erros nas bordas, e consiga uma interpolante cujo erro estará sempre abaixo da estimativa obtida pelo método adaptativo! In [35]: def polyfit_minsq(x,y,n): """ Calcula o polinômio de grau até n que melhor aproxima os pontos $(x_i, y_i)$. """ assert(len(x) == len(y)) maxx = max(x) minx = min(x) medx = (maxx + minx)/2 diffs = array(x) - medx M = [ones_like(x)] for i in range(n): M.append(M[-1]*diffs) M = array(m).t a,_,_,_ = lstsq(m,y) def p(z): return Horner(z - medx,a[::-1]) return p In [36]: def Horner(x, rcoeff): # Inicialização acc = rcoeff[0] for c in rcoeff[1:]: acc *= x acc += c return acc

12 In [37]: # Basta modificar a parte "interpolação" da qestão 10 Número de intervalos necessários: 27

13 In [39]: # E para completar, faça um gráfico com as faixas de erro: # limsup = limite superior para a primitiva real # liminf = limite inferior para a primitiva real # cand = candidata (= função numérica que você calculou) # primitiva = a primitiva analítica que você conhece! Número de intervalos necessários: 27