FORTRAN 90 - Calculos numericos
Upcoming SlideShare
Loading in...5
×
 

FORTRAN 90 - Calculos numericos

on

  • 1,671 views

 

Statistics

Views

Total Views
1,671
Views on SlideShare
1,309
Embed Views
362

Actions

Likes
0
Downloads
7
Comments
0

1 Embed 362

http://dafmet.wordpress.com 362

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

FORTRAN 90 - Calculos numericos FORTRAN 90 - Calculos numericos Document Transcript

  • CÁLCULOS NUMÉRICOS, PRECISÃO E ERROS DE ARREDONDAMENTO A linguagem Fortran foi, originalmente, designada para ajudar na solução de problemasnuméricos e está ainda é a maior classe de problemas para os quais programas em Fortran sãousados. Entretanto, é extremamente importante que o programador e o usuário destes programasestejam atentos às limitações intrínsecas de um computador na solução de problemas numéricos eaos passos que podem ser tomados para melhorar esta questão. Os números inteiros (INTEGER) são armazenados exatamente, sem qualquer partefracionária, e todos os cálculos realizados neles, exceto a divisão, levam a um resultado que ématematicamente preciso. Poderia haver, entretanto, um problema se, por exemplo, a soma de doisinteiros exceder o maior inteiro que um computador pudesse armazenar. No caso da divisão,qualquer parte fracionária no resultado (matemático) é descartada. Tipicamente, os números inteirospodem estar no intervalo -109 a +109. Os números inteiros são normalmente usados para contagens eoperações similares. Os números reais (REAL), por outro lado, são armazenados como uma aproximação aovalor matemático por meio de uma representação conhecida como ponto flutuante, que permite oarmazenamento de um amplo intervalo de valores em um mesmo grau de precisão. Tipicamente, umnúmero real será armazenado em um computador com aproximadamente seis ou sete dígitosdecimais de precisão, com expoente variando entre -10 38 e +1038. Alguns computadores,particularmente aqueles da classe de supercomputadores, excedem consideravelmente estesintervalos. Os cálculos numéricos usam, normalmente, números reais e, a menos que informado,esta discussão sobre métodos numéricos assumirá que todos os números são reais. Uma vez estabelecido que os números reais usados em cálculos numéricos sãoaproximações, mantido um determinado grau de precisão, devemos analisar que efeito isto pode ternos resultados destes cálculos. Para ilustrar esta questão mais facilmente, vamos assumir a existência de umcomputador que armazena os seus números em uma forma normalizada de ponto flutuantedecimal, ou seja, em um decimal equivalente à maneira na qual os números em ponto flutuante(binários) são armazenados num computador típico. Ainda, assumiremos que estes números sãoarmazenados com precisão de quatro dígitos. Finalmente, assumiremos, também, que o expoentedeve ficar no intervalo -9 a +9. Então, um número decimal normalizado e não nulo terá a forma0.d1d2d3d4 x 10p, sendo que d1 abrange o intervalo 1-9 e d2, d3 e d4 abrangem o intervalo 0-9. Onúmero 0.d1d2d3d4 é chamado de mantissa, enquanto que p é chamado de expoente. A Tabela 1mostra alguns exemplos da maneira que números são armazenados neste computador.
  • Tabela 1: Armazenamento de números1 em um computador de ponto flutuante decimal.Valor externo Representação interna37.5 0.3750 x 102123.456 0.1235 x 103123456789.12345 0.1234 x 1099876543210.1234 não pode ser representado – expoente = 100.0000012345678 0.1234 x 10-50.9999999999999 0.1 x 1010.0000000000375 não pode ser representado – expoente = -101 Aqui é usado ponto, ao invés da vírgula, como separador decimal. Note que dois dos números apresentados na Tabela 1 não podem ser representados emnosso computador decimal. O primeiro destes, 9 876 543 210.123 45, necessitaria de um expoenteigual a 10, maior que o computador permite. Qualquer tentativa de armazenar um número cujoexpoente é muito grande criará uma condição conhecida como overflow e, normalmente, causaráum erro neste estágio do processamento. Obviamente, uma vez que um cálculo tenha gerado umacondição como esta, os cálculos subsequentes, que usam este resultado, estarão incorretos. Uma situação similar surge com o último número da Tabela 1, 0.000 000 000 037 5,que necessitaria de um expoente igual a -10, menor que o permitido pelo computador. Esta situaçãoé conhecida como underflow, menos séria que o overflow, uma vez que o efeito é que um númeroestá muito próximo de zero para ser distinguido de zero. Muitos computadores não reportarão istona forma de erro e armazenarão o número como zero. Em alguns cálculos, entretanto, é importantesaber quando a situação de underflow ocorreu; alguns computadores relatam a sua ocorrência comoum erro não fatal. Em particular, um underflow não relatado pode resultar em uma tentativa dedivisão por zero, se o divisor é muito pequeno ou num resultado errado de um teste para um númeronulo. Agora, podemos visualizar como o nosso computador decimal fará cálculos aritméticossimples. Antes de seguir adiante, entretanto, notamos que a maioria dos computadores realizamoperações aritméticas em um conjunto especial de registradores1 que permitem a utilização de maisdígitos de precisão que a memória principal. Portanto, assumiremos que o nosso computador temregistros aritméticos capazes de armazenar números de oito dígitos decimais – isto é, o dobro daprecisão da memória. Quando o resultado de uma operação aritmética é armazenado na memória,assumiremos que ele será arredondado à precisão do computador – em nosso caso, quatro dígitosdecimais.1 Maiores detalhes sobre registradores em http://en.wikipedia.org/wiki/Processor_register.
  • Considere, primeiro, a soma de duas frações 11/9 e 1/3. O primeiro número, 11/9, seráarmazenado como 0.1222 x 101 em nosso computador, enquanto que o segundo, 1/3, seráarmazenado como 0.3333 x 100. Entretanto, antes que estes números possam ser somados, elesdevem ser convertidos para terem o mesmo expoente, sendo que os dígitos após espaço na descriçãoa seguir representam os dígitos extras, disponíveis nos registradores aritméticos:0.1222 x 101 + 0.0333 3 x 101 → 0.1555 3 x 101 (nos registradores) → 0.1555 x 101 (na memória) Observe que o processo é tomar o número com expoente mais baixo e então aumentá-loaté atingir o expoente do outro número, fazendo o deslocamento correspondente na mantissa para adireita (então, desnormalizando-a). A representação interna correta de (11/9 + 1/3), ou seja 14/9, é 0.1556 x 10 1 e éimportante notar que mesmo neste cálculo simples, realizado em aritmética de ponto flutuante,introduziu-se um erro no quarto dígito significante devido ao arredondamento feito durante ocálculo. Considere, agora, o resultado de um cálculo um pouco mais longo, no qual cinconúmeros, 4, 0.0004, 0.0004, 0.0004 e 0.0004, são somados. Uma vez que cálculos aritméticos emcomputadores sempre envolvem apenas dois operandos em cada estágio, os passos são comoseguem:(1) 0.4000 x 101 + 0.0000 4 x 101 → 0.4000 4 x 101 (nos registradores) → 0.4000 x 101 (na memória)(2) 0.4000 x 101 + 0.0000 4 x 101 → 0.4000 4 x 101 (nos registradores) → 0.4000 x 101 (na memória)etc. O resultado será 0.4000 x 101, ou seja, 4.0, quando podemos facilmente ver que seria4.002, arredondado para quatro dígitos significativos. A denormalização forçou alguns dos númerostornarem-se efetivamente nulos durante o processo de adição. Agora, considere o que acontece se a adição for realizada na ordem inversa:(1) 0.4000 x 10-3 + 0.4000 x 10-3 → 0.8000 x 10-3 (nos registradores) → 0.8000 x 10-3 (na memória)(2) 0.8000 x 10-3 + 0.4000 x 10-3 → 1.2000 x 10-3 (nos registradores) → 0.1200 0 x 10-2 (nos registradores)
  • → 0.1200 x 10-2 (na memória)(3) 0.1200 x 10-2 + 0.0400 0 x 10-2 → 0.1600 x 10-2 (nos registradores) → 0.1600 x 10-2 (na memória)(4) 0.0001 6 x 101 + 0.4000 x 101 → 0.4001 6 x 101 (nos registradores) → 0.4002 x 101 (na memória) Então, neste caso o resultado é 4.002, que é a resposta correta para quatro dígitossignificativos. Este exemplo mostra que, sempre que possível, é preferível adicionar númerospositivos para aumentar o valor do resultado, com o objetivo de minimizar os erros devido aoarredondamento. Similarmente, é preferível adicionar números negativos para diminuir o valor, como mesmo objetivo. Um exemplo muito mais sério de problemas envolvendo arrendondamento surge aosubtrair dois números. Considere, por exemplo, o efeito de subtrair 12/41 de 5/17. 5/17 érepresentado como 0.2941 x 100 e 12/41 como 0.2927 x 10 0 em nosso computador decimal e, então,a subtração procede como segue: 0.2941 x 100 – 0.2927 x 100 → 0.0014 x 100 (nos registradores) → 0.1400 x 10-2 (na memória) Entretanto, 5/17-12/41 é igual a 1/697, ou 0.1435 x 10 -2. O erro no cálculo é, portanto,da ordem de 2,4%, o qual é, dificilmente, a precisão que esperamos de um computador – mesmo nonosso caso hipotético. Este exemplo ilustra que deve-se sempre ter cuidado ao subtrair números que podemser quase idênticos (ou ao somar uma série de números que podem ser positivos e negativos), pois aperda de precisão resultante dos cálculos em ponto flutuante pode afetar seriamente a precisão doscálculos. O leitor fica alertado que mesmo tendo-se mostrado este problema com umcomputador hipotético com somente quatro dígitos significativos, máquinas reais com seis ou maisdígitos significativos encontram os mesmos problemas de arredondamento. Mostramos aqui quepodem haver problemas de arredondamento após apenas quatro ou cinco adições. Os computadoresmodernos são capazes de velocidades superiores a um bilhão de operações de ponto flutuante emum segundo. Ainda mais, alguns problemas podem rodar por dias, mesmo em máquinas rápidas. Para mitigar os efeitos de arredondamento, deve-se prestar atenção aos algoritmosnuméricos empregados e à precisão com a qual as operações aritméticas serão realizadas. Oprimeiro tópico é discutido em mais detalhes em livros de análise numérica. Com respeito ao
  • segundo tópico, a linguagem Fortran fornece vários tipos de variáveis numéricas para aquelas partesde um cálculo nas quais a perda de precisão pode ser séria. Para muitos problemas, embora nemtodos, o aumento da precisão dos cálculos em ponto flutuante é suficiente para obter respostassatisfatórias.FONTE: ELLIS, T. M. R.; PHILIPS, I. R.; LAHEY, T. M. Fortran 90 Programming. New York:Addison-Wesley. 1994. 825p.