Roteiro para o Primeiro Laboratório de Cálculo Numérico

Transcrição

1 Roteiro para o Primeiro Laboratório de Cálculo Numérico Prof. Dr. Waldeck Schützer April 7, 2008 Nesta aula de laboratório, vamos ter o nosso primeiro contato com um programa de computador dedicado ao Cálculo Numérico. Ele se chama Octave e é um irmão gêmeo do MatLab. Na sua área de trabalho, localize o ícone do Octave e clique sobre ele com o mouse para abrir o programa. Ao fazer isso, você provavelmente verá a seguinte janela de texto: GNU Octave, version (i486-pc-linux-gnu). Copyright (C) 2006 John W. Eaton. This is free software; see the source code for copying conditions. There is ABSOLUTELY NO WARRANTY; not even for MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE. For details, type warranty. Additional information about Octave is available at Please contribute if you find this software useful. For more information, visit Report bugs to <bug@octave.org> (but first, please read to learn how to write a helpful report). octave:1> A última linha exibindo octave:1> informa que o programa está pronto para receber comandos. Chamamos essa sentença de prompt, em referência ao estado de prontidão do programa. Nesse momento, podemos digitar uma expressão matemática como 1+1 ou 2*7 (note que a multiplicação é indicada pelo asterísco). Experimente fazer isso agora: octave:1> 2*7 ans = 14 octave:2> Observe que a linha abaixo do prompt informa ans = 14, ou seja a resposta (ANSwer) do comando que você digitou é igual a 14. O Octave seria de muito pouca utilidade se não fosse capaz de recordar o resultado de cálculos feitos previamente. Para isso dispõe do recurso de guardar valores calculados em variávieis. Observe que a palavra ans é o nome de uma variável que contém sempre o resultado do último comando executado. Você pode indicar um outro nome de varável, por exemplo: octave:2> raiz=sqrt(2) raiz = octave:3> A variavel raiz contém agora o valor , ou aproximadamente raiz quadrada de 2. A propósito, a esta altura você já notou que o Octave está contando os comandos, certo? Em um comando subsequente, você pode utilizar o valor armazenado previamente em uma variável. Por exemplo: octave:3> x=(1+raiz)/2 x = Aqui fizemos o cálculo x = cujo resultado aproximado é foi guardado na variável x. Você já deve ter reparado que as respostas numéricas do Octave são sempre com 5 dígitos significativos. Dizemos que esse é o format short do Octave. Para respostas com mais dígitos, podemos usar o seguinte comando: 1

2 octave:4> format long octave:5> raiz raiz = Perceberam como agora o valor aproximado de 2 que estava guardado na variável raiz parece estar mais preciso? De fato, esse valor já havia sido calculado com mais precisão e apenas uns poucos dígitos estavam sendo exibidos. Vamos agora determinar o maior e o menor número positivo no Octave: octave:6> realmax realmax = e+308 octave:7> realmin realmin = e-308 Entendeu? Isso foi bastante intuitivo e parece sugerir que o sistema do octave é equivalente a F(10,15,308,308). Agora talvez seja boa idéia voltarmos ao formato short: octave:8> format short Sempre podemos pedir o formato long quando desejarmos e sabemos que há mais dígitos à nossa disposição do que os que estão sendo exibidos. Neste curso estamos interessados em encontrar zeros de funções. Vamos ver agora como fazer para definir uma função. Considere o polinômio y = f(x) = x 3 6x + 2. Na linguagem do Octave, o escreveríamos como: octave:9> function y=f(x) > y=x.^3-6*x+2; > endfunction Note que o símbolo para potenciação é.ˆ (ponto-chapéu). Daí podemos calcular valores desse polinômio para valores particulares de x usando a sintaxe familiar: octave:10> f(0) ans = 2 octave:11> f(-1) ans = 7 octave:12> f(2) ans = -2 Para calcular o valor do polinômio em vários pontos consecutivos, por exemplo os inteiros entre -4 e 4, podemos usar os seguintes comandos: octave:13> x=-4:4 x = octave:14> y=f(x) y = Note que o primeiro comando criou um vetor x cujos elementos são os inteiros consecutivos desde -5 até 5. O segundo comando criou um outro vetor, y, contendo os respectivos valores do polinômio f calculados nesses inteiros. Podemos obter um gráfico desse polinômio usando usando estes valores calculados através do seguinte comando: octave:15> grid on octave:16> plot(x,y) O resultado desse comando pode ser visto na seguinte janela: 2

3 O comando grid on faz exibir a malha pontilhada e vemos o gráfico (aproximado) do polinômio em vermelho. Para obtermos um traçado mais suave, precisamos calcular o valor do polinômio em mais pontos intermediários. Para introduzir mais três pontos intermediários entre cada inteiro, podemos usar espaçamento (ou incremento) igual a Vamos fazer isso agora: octave:11> x=-4:0.25:4; octave:12> Note que estamos usando ; no final do comando para omitir a exibição do (longo) resultado. Antes de plotar o gráfico precisamos recalcular os valores de f: octave:12> y=f(x); plot(x,y) O resultado pode ser visto abaixo: Note como agora o traçado parece ser mais suave. Esse gráfico sugere ainda que esse polinômio apresenta três raízes reais distintas nos respectivos intervalos [-3,-2], [0,1] e [2,3]. De fato vemos, por exemplo, que: octave:13> f(0) ans = 2 octave:14> f(1) ans = -3 ou seja, f(x) muda de sinal no intervalo [0,1]. Vamos agora encontrar uma aproximação para a raiz positiva em [0,1] usando bisecção. octave:15> a0=0; b0=1; c0=(a0+b0)/2; y0=f(c0) y0 =

4 Vemos que o valor de f(x) no ponto médio do intervalo é aproximadamente Como f(a 0 )f(c 0 ) < 0, vemos que a raiz está no intervalo [a 0, c 0 ] = [0, 0.5]. Agora fazemos: octave:16> a1=a0; b1=c0; c1=(a1+b1)/2; y1=f(c1) y1 = Agora f(c 1 )f(b 1 ) < 0, logo a raiz está em [c 1, b 1 ] = [0.25, 0.5]. Poderíamos continuar com esses cálculos indefinidamente, mas é possível automatizar o processo usando laços e execução condicional. Laços permitem executar repetidamente um bloco de comandos e a execução condicional, como o nome já diz, permite executar um bloco de comandos apenas se uma determinada condição estiver satisfeita. Para o método da bissecção, devemos obeservar uma condição de parada e impor uma limitação no número de iterações. Assumindo que o intervalo inicial contendo a raiz seja dado pelas variáveis a e b, a precisão desejada ε esteja guardada na variável eps e que o número máximo de iterações seja N, então o seguinte bloco de comandos realiza a aproximação por bissecção: octave:17> a=0; b=1; eps=0.5e-3; N=20; i=0; octave:18> while (b-a)/2 > eps & i<n > c=(a+b)/2; > if f(a)*f(c)<0; b=c else a=c endif; > i=i+1; > endwhile b = a = b = a = b = a = a = a = b = b = Neste bloco o comando while (b-a)/2 > eps & i<n > c=(a+b)/2; pede a execução iterada do bloco de comandos subsequente até o comando endwhile enquanto as condições (b-a)/2 > eps e i<n forem verdadeiras, ou seja b a 2 e i < N. Aqui a variável i é usada para contar o número de iterações. Isso não é estritamente necessário para a bissecção, pois sabemos de antemão quantas iterações serão realizadas, mais é uma boa prática de programação. Os valores finais de a e b indicam um intervalo menor contendo a raiz: octave:19> a a = octave:20> b b = ou seja a raiz está no intervalo [ , ]. Podemos tomar o ponto médio desse intervalo como uma aproximação para a raiz: octave:21> x=(a+b)/2 x = Para chegar a esse resultado foram feitas 10 iterações e o erro absoluto é inferior a = , ou seja, devemos ter (pelo menos) duas casas decimais corretas. Vamos agora aplicar o Método de Newton a esse polinômio no intevalo [a, b] = [0, 1]. Para isso vamos precisar de f (x) = 3x 2 6. Chamando f de df na linguagem do Octave, escrevemos: octave:22> function y=df(x); y=3*x.^2-6; endfunction Devemos definir também a função de iteração ϕ(x) = x f(x) f (x) octave:23> function y=phi(x); y=x-f(x)/df(x); endfunction do médoto de Newton: Antes, porém, é bom nos certificarmos de que o Método irá convergir. Para isso vamos checar as condições do Newton. Para isso, vamos precisar também de f (x) = 6x, ou em Octave: octave:24> function y=ddf(x); y=6*x; endfunction 4

5 Tomando, por exemplo, x 0 = 0.5, temos f(x 0 )f (x 0 ) = < 0, logo essa não parece ser uma boa escolha, pois precisamos de f(x 0 )f (x 0 ) > 0. Por outro lado, se tomarmos x 0 = 0.1, temos f(x 0 )f (x 0 ) = > 0. Além disso, devemos nos certificar de que f (x) e f (x) conservam sinal no intervalo [a, b]. Como as raízes de f (x) são 2 e 2, e sabemos que f conserva sinal entre elas por ser função contínua, então em particular vemos que f conserva sinal em [0, 1]. É muito óbvio que o mesmo se pode dizer de f (x), logo todas as condições estão satisfeias e a convergência está garantida. Resta-nos agora fazer as iterações. Para isso vamos escrever um laço de programa como fizemos acima. Novamente eps será a precisão desejada, N será o número máximo de iterações, i será o contador de iterações e x=0.1 será a aproximação inicial. octave:25> i=1; eps=0.5e-3; N=20; x=0.1; x1=phi(x); octave:26> while i<n & abs(x1-x)/abs(x1)>eps; > x=x1; > i=i+1; > x1=phi(x); > endwhile Após executar esses comandos, temos os seguintes resultados: octave:27> x1 x1 = octave:28> i i = 3 ou seja, após 3 iterações atingimos a precisão desejada ε = Se mais tarde desejarmos repetir os calculos teremos que repetir os comandos acima. Por que não criarmos uma função para fazer exatamente isso? octave:28> function [y,i,er]=newton(x,eps,n); > i=1; > y=phi(x); > er = abs(y-x)/abs(y); > while i<n & er>eps; > x=y; > i=i+1; > y=phi(x); > er=abs(y-x)/abs(y); > endwhile; > endfunction Agora podemos chamar essa função para fazer as iterações a partir de um valor inicial x, uma precisão desejada eps e até um número máximo de iterações N. Note que o resultado será um vetor [y,i,er], onde y é a aproximação obtida para a raiz, i é o número de iterações realizadas e er é o erro relativo calculado. Por exemplo: octave:29> [y,i,er]=newton(0.1,0.5e-3,20) y = i = 3 er = e-05 ou seja, para x 0 = 0.1, ε = e N = 20, o resultado é y = , i = 3 e E r = Vamos mudar para a exibição longa e executar novamente o Newton para x 0 = 0.1, ε = e N = 20: octave:30> format long octave:31> [y,i,er]=newton(0.1,0.5e-10,20) y = i = 4 er = e-11 Este exemplo ilustra bem o poder do Método de Newton. Com apenas mais uma iteração em relação ao exemplo anterior, atingimos a precisão de 10 casas decimais exatas! Um aperfeiçoamento do que fizemos até aqui seria usarmos uma função para calcular o valor de f e de f usando o Briot-Ruffini: 5

6 octave:32> function [y,dy]=briot(p,x); > n=size(p)(2); > y=p(1); > dy=p(1); > for i=2:n; > y=y*x+p(i); > if i<n; dy=dy*x+y; endif; > endfor; > endfunction Aqui estamos supondo que os coeficientes do polinômio estejam guardados em um vetor p. Estude cuidadosamente o laço apresentado acima para certificar-se de que ele implementa corretamente o Briot-Ruffini para f e f. O comando n=size(p)(2) obtém o comprimento do vetor p. O sufixo (2) é usado pois a resposta de size são dois índices: [colunas,linhas], e queremos apenas as linhas. Para o exemplo do polinômio f(x) = x 3 6x + 2, esse vetor seria p = [1, 0, 6, 2]. Usando a linguagem do Octave escreveríamos: octave:33> p=[ ]; size(p) ans = 1 4 Agora vamos testar o Briot: octave:34> [y,z]=briot(p,0) y = 2 z = -6 octave:35> f(0) ans = 2 octave:36> df(0) ans = -6 Onde vemos que nossa função retornos os valores corretos para f(0)e f (0). Experimente modificar a função ϕ (ou phi na linguagem do Octave) para utilizar a função briot ao invés de f e df. Agora que você já entendeu o básico sobre o Octave, este é um bom momento para experimentar com os outros métodos com Secantes, Posição Falsa, e MIL. Isso fica como exercício! Procure ter à mão um bom manual do Octave, como o que está disponível no site: Boa sorte! 6