Cálculo Numérico

Um Livro Colaborativo
Versão Python

21 de junho de 2017
Organizadores

Dagoberto Adriano Rizzotto Justo - UFRGS

Esequia Sauter - UFRGS

Fabio Souto de Azevedo - UFRGS

Leonardo Fernandes Guidi - UFRGS

Matheus Correia dos Santos - UFRGS

Pedro Henrique de Almeida Konzen - UFRGS

ii
Licença

Este trabalho está licenciado sob a Licença Creative Commons Atribuição-

CompartilhaIgual 3.0 Não Adaptada. Para ver uma cópia desta licença, visite
http://creativecommons.org/licenses/by-sa/3.0/ ou envie uma carta para Creative
Commons, PO Box 1866, Mountain View, CA 94042, USA.

iii
Nota dos organizadores

Estamos escrevendo este livro de forma colaborativa desde 2011 e, recente-

mente, decidimos por abrir à colaborações externas. Nosso objetivo é produzir um
material didático no nível de graduação de excelente qualidade e de acesso livre
pela colaboração entre professores e alunos de universidades, institutos de educa-
ção e demais interessados na análise, estudo e aplicação de métodos numéricos nos
mais diversos ramos da ciência e da tecnologia.
O sucesso do projeto depende da colaboração! Edite você mesmo o livro, dê
sugestões ou nos avise de erros e imprecisões. Toda a colaboração é bem vinda.
Saiba mais visitando o site oficial do projeto:

http://www.ufrgs.br/numerico

Nós preparamos uma série de ações para ajudá-lo a participar. Em primeiro

lugar, o acesso irrestrito ao livro pode se dar através do site oficial do projeto.
Disponibilizamos o livro na versão original em PDF e versões adaptadas em HTML,
EPUB e Slides. Além disso, o livro está escrito em código LATEX disponível em
repositório GitHub público.
Nada disso estaria completo sem uma licença apropriada à colaboração. Por
isso, escolhemos disponibilizar o material do livro sob licença Creative Commons
Atribuição-CompartilhaIgual 3.0 Não Adaptada (CC-BY-SA 3.0). Ou seja, você
pode copiar, redistribuir, alterar e construir um novo material para qualquer uso,
inclusive comercial. Leia a licença para maiores informações.

Desejamos-lhe ótimas colaborações!

iv
Prefácio

Este livro busca abordar os tópicos de um curso de introdução ao cálculo numé-

rico moderno oferecido a estudantes de matemática, física, engenharias e outros.
A ênfase é colocada na formulação de problemas, implementação em computador
da resolução e interpretação de resultados. Pressupõe-se que o estudante domine
conhecimentos e habilidades típicas desenvolvidas em cursos de graduação de cál-
culo, álgebra linear e equações diferenciais. Conhecimentos prévios em linguagem
de computadores é fortemente recomendável, embora apenas técnicas elementares
de programação sejam realmente necessárias.
Nesta versão do livro, fazemos ênfase na utilização da linguagem computacional
Python para a implementação dos métodos numéricos abordados. Recomendamos
ao leitor ter à sua disposição um computador com o interpretador Python 2.7
(ou superior) e o conjunto de biblioteca SciPy instalados. Não é necessário estar
familiarizado com esta linguagem, mas recomendamos a leitura do Apêndice A,
no qual apresentamos uma rápida introdução a esta linguagem com ênfase naquilo
que é mais essencial para a leitura do livro. Alternativamente, existem algumas
soluções em nuvem que fornecem acesso a consoles online Python. Veja, por
exemplo, o SageMathCloud.
Os códigos computacionais dos métodos numéricos apresentados no livro são
implementados em uma abordagem didática. Isto é, temos o objetivo de que a im-
plementação em linguagem computacional venha a auxiliar o leitor no aprendizado
das técnicas numéricas que são apresentadas no livro. Implementações computa-
cionais eficientes de técnicas de cálculo numérico podem ser obtidas na série de
livros “Numerical Recipes”, veja [10].

v
Sumário

Capa i

Organizadores ii

Licença iii

Nota dos organizadores iv

Prefácio v

Sumário x

1 Introdução 1

2 Representação de números e aritmética de máquina 3

2.1 Sistema de numeração e mudança de base . . . . . . . . . . . . . . 3
2.2 Notação científica e notação normalizada . . . . . . . . . . . . . . . 10
2.2.1 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Representação decimal finita . . . . . . . . . . . . . . . . . . . . . . 11
2.3.1 Arredondamento de números . . . . . . . . . . . . . . . . . . 12
2.4 Representação de números em máquina . . . . . . . . . . . . . . . . 13
2.4.1 Números inteiros . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.2 Sistema de ponto fixo . . . . . . . . . . . . . . . . . . . . . . 16
2.4.3 Sistema de ponto flutuante . . . . . . . . . . . . . . . . . . . 17
2.4.4 Precisão e épsilon de máquina . . . . . . . . . . . . . . . . . 20
2.4.5 Distribuição dos números . . . . . . . . . . . . . . . . . . . . 20
2.5 Tipos de erros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.6 Erros nas operações elementares . . . . . . . . . . . . . . . . . . . . 25
2.7 Cancelamento catastrófico . . . . . . . . . . . . . . . . . . . . . . . 25
2.8 Condicionamento de um problema . . . . . . . . . . . . . . . . . . . 28
2.9 Mais exemplos de cancelamento catastrófico . . . . . . . . . . . . . 33

vi
SUMÁRIO vii

3 Solução de equações de uma variável 43

3.1 Existência e unicidade . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.2 Método da bisseção . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.2.1 Código Python: método da bisseção . . . . . . . . . . . . . . 50
3.3 Iteração de ponto fixo . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.3.1 Teorema do ponto fixo . . . . . . . . . . . . . . . . . . . . . 57
3.3.2 Teste de convergência . . . . . . . . . . . . . . . . . . . . . . 60
3.3.3 Estabilidade e convergência . . . . . . . . . . . . . . . . . . 61
3.3.4 Erro absoluto e tolerância . . . . . . . . . . . . . . . . . . . 62
3.4 Método de Newton-Raphson . . . . . . . . . . . . . . . . . . . . . . 68
3.4.1 Interpretação geométrica . . . . . . . . . . . . . . . . . . . . 69
3.4.2 Análise de convergência . . . . . . . . . . . . . . . . . . . . 70
3.5 Método das secantes . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.5.1 Interpretação geométrica . . . . . . . . . . . . . . . . . . . . 76
3.5.2 Análise de convergência . . . . . . . . . . . . . . . . . . . . 77
3.6 Critérios de parada . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
3.7 Exercícios finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

4 Solução de sistemas lineares 87

4.1 Eliminação gaussiana . . . . . . . . . . . . . . . . . . . . . . . . . . 89
4.1.1 Eliminação gaussiana com pivotamento parcial . . . . . . . . 91
4.2 Complexidade de algoritmos em álgebra linear . . . . . . . . . . . . 96
4.3 Sistemas triangulares . . . . . . . . . . . . . . . . . . . . . . . . . . 99
4.4 Fatoração LU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4.4.1 Código Python: Fatoração LU . . . . . . . . . . . . . . . . . 102
4.4.2 Custo computacional para resolver um sistema linear usando
fatoração LU . . . . . . . . . . . . . . . . . . . . . . . . . . 102
4.4.3 Custo para resolver m sistemas lineares . . . . . . . . . . . . 103
4.4.4 Custo para calcular a matriz inversa de A . . . . . . . . . . 103
4.5 Método da matriz tridiagonal . . . . . . . . . . . . . . . . . . . . . 104
4.6 Condicionamento de sistemas lineares . . . . . . . . . . . . . . . . . 111
4.6.1 Norma de vetores . . . . . . . . . . . . . . . . . . . . . . . . 112
4.6.2 Norma de matrizes . . . . . . . . . . . . . . . . . . . . . . . 113
4.6.3 Número de condicionamento . . . . . . . . . . . . . . . . . . 114
4.7 Métodos iterativos para sistemas lineares . . . . . . . . . . . . . . . 117
4.7.1 Método de Jacobi . . . . . . . . . . . . . . . . . . . . . . . . 117
4.7.2 Método de Gauss-Seidel . . . . . . . . . . . . . . . . . . . . 119
4.7.3 Análise de convergência . . . . . . . . . . . . . . . . . . . . 121
4.8 Cálculo de autovalores e autovetores . . . . . . . . . . . . . . . . . 130
4.8.1 Método da Potência . . . . . . . . . . . . . . . . . . . . . . 130
4.8.2 Método da iteração Inversa . . . . . . . . . . . . . . . . . . 134

Licença CC-BY-SA-3.0. Contato: [email protected]

 viii Cálculo Numérico

4.9 Exercícios finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

5 Solução de sistemas de equações não lineares 138

5.1 Método de Newton para sistemas . . . . . . . . . . . . . . . . . . . 141
5.1.1 Código Python: Newton para Sistemas . . . . . . . . . . . . 144
5.2 Linearização de uma função de várias variáveis . . . . . . . . . . . . 152
5.2.1 Gradiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
5.2.2 Matriz jacobiana . . . . . . . . . . . . . . . . . . . . . . . . 153

6 Interpolação 156
6.1 Interpolação polinomial . . . . . . . . . . . . . . . . . . . . . . . . . 157
6.2 Diferenças divididas de Newton . . . . . . . . . . . . . . . . . . . . 161
6.3 Polinômios de Lagrange . . . . . . . . . . . . . . . . . . . . . . . . 163
6.4 Aproximação de funções reais por polinômios interpoladores . . . . 164
6.5 Interpolação linear segmentada . . . . . . . . . . . . . . . . . . . . 167
6.6 Interpolação cúbica segmentada - spline . . . . . . . . . . . . . . . . 168
6.6.1 Spline natural . . . . . . . . . . . . . . . . . . . . . . . . . . 171
6.6.2 Spline fixado . . . . . . . . . . . . . . . . . . . . . . . . . . 173
6.6.3 Spline not-a-knot . . . . . . . . . . . . . . . . . . . . . . . . 174
6.6.4 Spline periódico . . . . . . . . . . . . . . . . . . . . . . . . . 175

7 Ajuste de curvas 177

7.1 Ajuste de uma reta . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
7.2 Ajuste linear geral . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
7.2.1 Ajuste polinomial . . . . . . . . . . . . . . . . . . . . . . . . 188
7.3 Aproximando problemas não lineares por problemas lineares . . . . 192

8 Derivação Numérica 197

8.1 Diferenças finitas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
8.1.1 Diferenças finitas via série de Taylor . . . . . . . . . . . . . 199
8.1.2 Erros de arredondamento . . . . . . . . . . . . . . . . . . . . 203
8.2 Diferença finita para derivada segunda . . . . . . . . . . . . . . . . 207
8.3 Obtenção de fórmulas por polinômios interpoladores . . . . . . . . . 208
8.3.1 Exercícios resolvidos . . . . . . . . . . . . . . . . . . . . . . 211
8.4 Fórmulas de diferenças finitas . . . . . . . . . . . . . . . . . . . . . 211
8.5 Derivada via ajuste ou interpolação . . . . . . . . . . . . . . . . . . 214
8.6 Exercícios finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

9 Integração Numérica 216

9.1 Regras de Newton-Cotes . . . . . . . . . . . . . . . . . . . . . . . . 218
9.1.1 Somas de Riemann . . . . . . . . . . . . . . . . . . . . . . . 219

Licença CC-BY-SA-3.0. Contato: [email protected]

SUMÁRIO ix

9.1.2 Regra do trapézio . . . . . . . . . . . . . . . . . . . . . . . . 220

9.1.3 Regra de Simpson . . . . . . . . . . . . . . . . . . . . . . . . 222
9.2 Obtenção das regras de quadratura . . . . . . . . . . . . . . . . . . 226
9.3 Regras compostas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
9.3.1 Método composto dos trapézios . . . . . . . . . . . . . . . . 228
9.3.2 Método composto de Simpson . . . . . . . . . . . . . . . . . 229
9.4 O método de Romberg . . . . . . . . . . . . . . . . . . . . . . . . . 231
9.5 Ordem de precisão . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
9.6 Quadratura de Gauss-Legendre . . . . . . . . . . . . . . . . . . . . 240
9.7 Exercícios finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244

10 Problemas de valor inicial 248

10.1 Teoria de equações diferenciais . . . . . . . . . . . . . . . . . . . . . 249
10.2 Método de Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
10.2.1 Ordem de precisão . . . . . . . . . . . . . . . . . . . . . . . 255
10.2.2 Erro de truncamento Local . . . . . . . . . . . . . . . . . . . 256
10.2.3 Erro de truncamento Global . . . . . . . . . . . . . . . . . . 257
10.3 Convergência, consistência e estabilidade . . . . . . . . . . . . . . . 257
10.3.1 Convergência . . . . . . . . . . . . . . . . . . . . . . . . . . 257
10.3.2 Consistência . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
10.3.3 Estabilidade . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
10.4 O método de Euler implícito . . . . . . . . . . . . . . . . . . . . . . 259
10.5 Método Trapezoidal . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
10.6 O método de Heun . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
10.7 O método theta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
10.8 O método de Taylor . . . . . . . . . . . . . . . . . . . . . . . . . . 263
10.9 Estabilidade dos métodos de Taylor . . . . . . . . . . . . . . . . . . 263
10.10Métodos de Passo Múltiplo . . . . . . . . . . . . . . . . . . . . . . . 264
10.11O método de Adams-Bashforth . . . . . . . . . . . . . . . . . . . . 265
10.12O método de Adams-Moulton . . . . . . . . . . . . . . . . . . . . . 266
10.13Método BDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
10.14Ordem e convergência de métodos de passo múltiplo . . . . . . . . . 268
10.14.1 Consistência, Estabilidade e Convergência . . . . . . . . . . 268
10.14.2 As barreiras de Dahlquist . . . . . . . . . . . . . . . . . . . 269
10.15Estabilidade dos métodos de passo múltiplo . . . . . . . . . . . . . 269
10.16Métodos de Runge-Kutta . . . . . . . . . . . . . . . . . . . . . . . . 270
10.16.1 Método de Runge-Kutta Explícito . . . . . . . . . . . . . . . 270
10.16.2 Método de RK ν = 2 . . . . . . . . . . . . . . . . . . . . . . 271
10.16.3 Método de Runge-Kutta implícito (IRK) . . . . . . . . . . . 272
10.17Estimativa da ordem de convergência . . . . . . . . . . . . . . . . . 273
10.17.1 Método 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274

Licença CC-BY-SA-3.0. Contato: [email protected]

 x Cálculo Numérico

10.17.2 Método 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274

10.18Sistemas de equações diferenciais e equações de ordem superior . . . 275
10.19Exercícios finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

11 Problemas de Valores de Contorno 281

11.1 Método de Diferenças Finitas . . . . . . . . . . . . . . . . . . . . . 281

A Rápida Introdução ao Python 293

A.1 Sobre a linguagem Python . . . . . . . . . . . . . . . . . . . . . . . 293
A.1.1 Instalação e Execução . . . . . . . . . . . . . . . . . . . . . 293
A.1.2 Usando Python . . . . . . . . . . . . . . . . . . . . . . . . . 294
A.2 Elementos da linguagem . . . . . . . . . . . . . . . . . . . . . . . . 295
A.2.1 Operações matemáticas elementares . . . . . . . . . . . . . . 296
A.2.2 Funções e constantes elementares . . . . . . . . . . . . . . . 296
A.2.3 Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . 297
A.3 Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
A.3.1 Obtendo dados de uma matriz . . . . . . . . . . . . . . . . . 298
A.3.2 Operações matriciais e elemento-a-elemento . . . . . . . . . 300
A.4 Estruturas de ramificação e repetição . . . . . . . . . . . . . . . . . 301
A.4.1 A instrução de ramificação “if” . . . . . . . . . . . . . . . . 301
A.4.2 A instrução de repetição “for” . . . . . . . . . . . . . . . . . 301
A.4.3 A instrução de repetição “while” . . . . . . . . . . . . . . . . 302
A.5 Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
A.6 Gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

Respostas dos Exercícios 305

Referências Bibliográficas 319

Colaboradores 320

Índice Remissivo 321

Licença CC-BY-SA-3.0. Contato: [email protected]

Capítulo 1

Introdução

Cálculo numérico é a disciplina que estuda as técnicas para a solução apro-

ximada de problemas matemáticos. Estas técnicas são de natureza analítica e
computacional. As principais preocupações normalmente envolvem exatidão e de-
sempenho.
Aliado ao aumento contínuo da capacidade de computação disponível, o desen-
volvimento de métodos numéricos tornou a simulação computacional de modelos
matemáticos uma prática usual nas mais diversas áreas científicas e tecnológicas.
As então chamadas simulações numéricas são constituídas de um arranjo de vários
esquemas numéricos dedicados a resolver problemas específicos como, por exemplo:
resolver equações algébricas, resolver sistemas lineares, interpolar e ajustar pontos,
calcular derivadas e integrais, resolver equações diferenciais ordinárias etc. Neste
livro, abordamos o desenvolvimento, a implementação, a utilização e os aspectos
teóricos de métodos numéricos para a resolução desses problemas.
Trabalharemos com problemas que abordam aspectos teóricos e de utilização
dos métodos estudados, bem como com problemas de interesse na engenharia, na
física e na matemática aplicada.
A necessidade de aplicar aproximações numéricas decorre do fato de que esses
problemas podem se mostrar intratáveis se dispomos apenas de meios puramente
analíticos, como aqueles estudados nos cursos de cálculo e álgebra linear. Por
exemplo, o teorema de Abel-Ruffini nos garante que não existe uma fórmula algé-
brica, isto é, envolvendo apenas operações aritméticas e radicais, para calcular as
raízes de uma equação polinomial de qualquer grau, mas apenas casos particulares:

• Simplesmente isolar a incógnita para encontrar a raiz de uma equação do

primeiro grau;

• Fórmula de Bhaskara para encontrar raízes de uma equação do segundo grau;

• Fórmula de Cardano para encontrar raízes de uma equação do terceiro grau;

1
 2 Cálculo Numérico

• Existe expressão para equações de quarto grau;

• Casos simplificados de equações de grau maior que 4 onde alguns coeficientes

são nulos também podem ser resolvidos.

Equações não polinomiais podem ser ainda mais complicadas de resolver exata-
mente, por exemplo:
cos(x) = x e xex = 10
Para resolver o problema de valor inicial

y 0 + xy = x,
y(0) = 2,

podemos usar o método de fator integrante e obtemos y = 1 + e−x . Já o cálculo

2 /2

da solução exata para o problema

y 0 + xy = e−y ,
y(0) = 2,

não é possível.
Da mesma forma, resolvemos a integral
Z 2
2
xe−x dx
1

pelo método da substituição e obtemos 21 (e−1 − e−2 ). Porém a integral

Z 2
2
e−x dx
1

não pode ser resolvida analiticamente.

A maioria dos modelos de fenômenos reais chegam em problemas matemáticos
onde a solução analítica é difícil (ou impossível) de ser encontrada, mesmo quando
provamos que ela existe. Nesse curso propomos calcular aproximações numéricas
para esses problemas, que apesar de, em geral, serem diferentes da solução exata,
mostraremos que elas podem ser bem próximas.
Para entender a construção de aproximações é necessário estudar um pouco
como funciona a aritmética de computador e erros de arredondamento. Como
computadores, em geral, usam uma base binária para representar números, come-
çaremos falando em mudança de base.

Licença CC-BY-SA-3.0. Contato: [email protected]

Capítulo 2

Representação de números e
aritmética de máquina

Neste capítulo, discutiremos sobre formas de representação de números em

computadores. Iniciamos com uma discussão sobre representação posicional e mu-
dança de base. Então, discutimos sobre representação com número de dígitos
finitos e, mais especificamente, as representações de números inteiros, ponto fixo e
ponto flutuante em computadores.
A representação de números e a aritmética em computadores levam aos cha-
mados erros de arredondamento e de truncamento. Ao final deste capítulo, discu-
tiremos sobre os efeitos do erro de arredondamento na computação científica.
Ao longo do capítulo, faremos alguns comentários usando códigos em Python 2.7.
Nestes, estaremos assumindo que os seguintes módulos estão carregados:
>>> from __future__ import division
>>> import numpy as np
A primeira instrução garante que divisões de números inteiros sejam computadas
em ponto flutuante (double) e a segunda carrega a biblioteca de computação
científica numpy.

2.1 Sistema de numeração e mudança de base

Usualmente, utilizamos o sistema de numeração decimal para representar nú-
meros. Esse é um sistema de numeração posicional onde a posição do dígito indica
a potência de 10 que o dígito está representando.
Exemplo 2.1.1. O número 293 é decomposto como
293 = 2 centenas + 9 dezenas + 3 unidades
= 2 · 102 + 9 · 101 + 3 · 100 .

3
 4 Cálculo Numérico

O sistema de numeração posicional também pode ser usado com outras bases.
Vejamos a seguinte definição.

Definição 2.1.1 (Sistema de numeração de base b). Dado um número natural

b > 1 e o conjunto de símbolos {±
±, 0 , 1 , 2 , . . . , b − 11}1 , a sequência de símbolos

(dn dn−1 · · · d1 d0 ,d−1 d−2 · · · )b

representa o número positivo

dn · bn + dn−1 · bn−1 + · · · + d0 · b0 + d−1 · b−1 + d−2 · b−2 + · · ·

Para representar números negativos usamos o símbolo − a esquerda do numeral2 .

Observação 2.1.1 (b ≥ 10). Para sistemas de numeração com base b ≥ 10 é usual

utilizar as seguintes notações:

• No sistema de numeração decimal (b = 10), costumamos representar o nú-

mero sem os parênteses e o subíndice, ou seja,

±dn dn−1 . . . d1 d0 ,d−1 d−2 . . . := ±(dn dn−1 . . . d1 d0 ,d−1 d−2 . . .)10 .

• Se b > 10, usamos as letras A, B, C, · · · para denotar os algarismos: A = 10,

B = 11, C = 12, D = 13, E = 14, F = 15.

Exemplo 2.1.2 (Sistema binário). O sistema de numeração em base dois é cha-

mado de binário e os algarismos binários são conhecidos como bits (do inglês bi-
nary digits). Um bit pode assumir dois valores distintos: 0 ou 1. Por exemplo:

x = (1001,101)2
= 1 · 23 + 0 · 22 + 0 · 21 + 1 · 20 + 1 · 2−1 + 0 · 2−2 + 1 · 2−3
= 8 + 0 + 0 + 1 + 0,5 + 0 + 0,125 = 9,625.

Ou seja, (1001,101)2 é igual a 9,625 no sistema decimal.

Em Python podemos converter o número (1001,101)2 para a base decimal com-
putando

>>> 1*2**3 + 0*2**2 + 0*2**1 + 1*2**0 + 1*2**-1 + 0*2**-2 + 1*2**-3

9.625
1
Para b > 10, veja a observação 2.1.1.
2
O uso do símbolo + é opcional na representação de números positivos.

Licença CC-BY-SA-3.0. Contato: [email protected]

2.1. SISTEMA DE NUMERAÇÃO E MUDANÇA DE BASE 5

Exemplo 2.1.3 (Sistema quaternário). No sistema quaternário a base b é igual a

4 e, portanto, temos o seguinte conjunto de algarismos {0, 1, 2, 3}. Por exemplo:

(301,2)4 = 3 · 42 + 0 · 41 + 1 · 40 + 2 · 4−1 = 49,5.

Verifique no computador!
Exemplo 2.1.4 (Sistema octal). No sistema octal a base é b = 8. Por exemplo:

(1357,24)8 = 1 · 83 + 3 · 82 + 5 · 81 + 7 · 80 + 2 · 8−1 + 4 · 8−2

= 512 + 192 + 40 + 7 + 0,25 + 0,0625 = 751,3125.

Verifique no computador!
Exemplo 2.1.5 (Sistema hexadecimal). O sistema de numeração cuja a base é
b = 16 é chamado de sistema hexadecimal. Neste, temos o conjunto de algarismos
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F }. Convertendo o número (E2AC)16 para
a base 10 temos
(E2AC)16 = 14 · 163 + 2 · 162 + 10 · 161 + 12 · 160
= 57344 + 512 + 160 + 12 = 58028.

Verifique no computador!
Observação 2.1.2. Python tem algumas sintaxes para representar números em
algumas bases. Por exemplo, temos:
>>> print(0b1001) #bin -> dec
9
>>> print(0157) #oct -> dec
111
>>> print(0xbeba) #hex -> dec
48826
Nos exemplos acima vimos como converter números representados em um sis-
tema de numeração de base b para o sistema decimal. Agora, vamos estudar
como fazer o processo inverso. Isto é, dado um número decimal (X)10 queremos
escrevê-lo em uma outra base b, isto é, queremos obter a seguinte representação:
(X)10 = (dn dn−1 · · · d0 ,d−1 · · · )b
= dn · bn + dn−1 · bn−1 + · · · + d0 · b0 + d−1 · b−1 + d−2 · b−2 + · · ·

Separando as partes inteira e fracionária de X, isto é, X = X i + X f , temos

X i = dn · bn + · · · + dn−1 bn−1 · · · + d1 · b1 + d0 · b0

Licença CC-BY-SA-3.0. Contato: [email protected]

 6 Cálculo Numérico

e
d−1 d−2
Xf =+ 2 + ···
b1 b
Nosso objetivo é determinar os algarismos {dn , dn−1 , ...}.
Primeiramente, vejamos como tratar a parte inteira X i . Calculando sua divisão
de X i por b, temos:

Xi d0
= + d1 + d2 · b1 + · · · + dn−1 · bn−2 + dn · bn−1 .
b b

Observe que d0 é o resto da divisão de X i por b, pois d1 + d2 · b1 + · · · + dn−1 ·

bn−2 + dn · bn−1 é inteiro e db0 é uma fração com d0 < b. Da mesma forma, o resto
da divisão de d1 + d2 · b1 + · · · + dn−1 · bn−2 + dn · bn−1 por b é d1 . Ou seja, repetindo
este processo encontramos os algarismos d0 , d1 , d2 , . . ., dn .
Vamos, agora, converter a parte fracionária X f do número decimal X para o
sistema de base b. Multiplicando X f por b, temos
d−2 d−3
bX f = d−1 + + 2 + ···
b b
Observe que a parte inteira desse produto é d−1 e d−2
b
+ db−3
2 + · · · é a parte fracio-

nária. Quando multiplicamos b + b2 + · · · por b novamente, encontramos d−2 .

d−2 d−3

Repetindo este processo encontramos os demais algarismos.

Exemplo 2.1.6. Vamos converter o número 9,625 para a base binária (b = 2).
Primeiramente, decompomos 9,625 na soma de suas partes inteira e fracionária.

9,625 = 9 + 0,625.

Conversão da parte inteira. Para converter a parte inteira, fazemos suces-

sivas divisões por b = 2 obtendo

9=4·2+1
= (2 · 2 + 0) · 2 + 1
= 23 + 1.

Ou seja, temos que 9 = (1001)2 . Em Python, podemos usar os comandos int

(truncamento) e a operação % (resto da divisão) para computar esta conversão da
seguinte forma
>>> x = 9
>>> d0 = x%2; x = int(x/2); print("d0 = %d, x = %d" % (d0,x))
d0 = 1, x = 4

Licença CC-BY-SA-3.0. Contato: [email protected]

2.1. SISTEMA DE NUMERAÇÃO E MUDANÇA DE BASE 7

>>> d1 = x%2; x = int(x/2); print("d1 = %d, x = %d" % (d1,x))

d1 = 0, x = 2
>>> d2 = x%2; x = int(x/2); print("d2 = %d, x = %d" % (d2,x))
d2 = 0, x = 1
>>> d3 = x%2; x = int(x/2); print("d3 = %d, x = %d" % (d3,x))
d3 = 1, x = 0

Conversão da parte fracionária. Para converter a parte fracionária, fazemos

sucessivas multiplicações por b = 2 obtendo

0,625 = 1,25 · 2−1 = 1 · 2−1 + 0,25 · 2−1

= 1 · 2−1 + (0,5 · 2−1 ) · 2−1 = 1 · 2−1 + 0,5 · 2−2
= 1 · 2−1 + (1 · 2−1 ) · 2−2 = 1 · 2−1 + 1 · 2−3 .

Ou seja, temos que 0,625 = (0,101)2 . Em Python, podemos computar esta con-
versão da parte fracionária da seguinte forma

>>> x=0.625
>>> d = int(2*x); x = 2*x - d; print("d = %d, x = %f" % (d,x))
d = 1, x = 0.250000
>>> d = int(2*x); x = 2*x - d; print("d = %d, x = %f" % (d,x))
d = 0, x = 0.500000
>>> d = int(2*x); x = 2*x - d; print("d = %d, x = %f" % (d,x))
d = 1, x = 0.000000

Conclusão. Da conversão das partes inteira e fracionária de 9,625, obtemos

9 = (1001)2 e 0,625 = (0,101)2 . Logo, concluímos que 9,625 = (1001,101)2 .

Observação 2.1.3. Python oferece algumas funções para a conversão de números

inteiros em base decimal para uma base dada. Por exemplo, temos:

>>> print(bin(9))
0b1001
>>> print(oct(111))
0157
>>> print(hex(48826))
0xbeba

Observação 2.1.4. Uma maneira de converter um número dado em uma base b1

para uma base b2 é fazer em duas partes: primeiro converter o número dado na
base b2 para base decimal e depois converter para a base b1 .

Licença CC-BY-SA-3.0. Contato: [email protected]

 8 Cálculo Numérico

Exercícios resolvidos
ER 2.1.1. Obtenha a representação do número 125,583̄ na base 6.
Solução. Decompomos 125,583̄ nas suas partes inteira 125 e fracionária 0,583̄.
Então, convertemos cada parte.
Conversão da parte inteira. Vamos escrever o número 125 na base 6. Para
tanto, fazemos sucessivas divisões por 6 como segue:
125 = 20 · 6 + 5 (125 dividido por 6 é igual a 20 e resta 5)
= (3 · 6 + 2) · 6 + 5 = 3 · 62 + 2 · 6 + 5,
logo 125 = (325)6 .
Estes cálculos podem ser feitos em Python com o auxílio do comando % e da
função int. Com o primeiro calculamos o resto da divisão entre dois números,
enquanto que a segunda retorna a parte inteira de um número dado. No nosso
exemplo, temos:
>>> q = 125; d0 = (q % 6); print(q,d0)
>>> q = int(q/6); d1 = (q % 6); print(q,d1)
>>> q = int(q/6); d2 = (q % 6); print(q,d2)
Verifique!
Conversão da parte fracionária. Para converter 0,583̄ para a base 6, faze-
mos sucessivas multiplicações por 6 como segue:
0,583 = 3,5 · 6−1 (0,583 multiplicado por 6 é igual a 3,5)
= 3 · 6−1 + 0,5 · 6−1
= 3 · 6−1 + (3 · 6−1 ) · 6−1
= 3 · 6−1 + 3 · 6−2 ,
logo 0,583 = (0,33)6 . As contas feitas aqui, também podem ser computadas em
Python. Você sabe como? ♦
ER 2.1.2. Obtenha a representação na base 4 do número (101,01)2 .
Solução. Começamos convertendo (101,01)2 para a base decimal:
(1001,101)2 = 1 · 22 + 1 · 20 + 1 · 2−2 = 5,25.
Então, convermetos 5,25 para a base 4. Para sua parte inteira, temos
5 = 1 · 4 + 1 = (11)4 .
Para sua parte fracionária, temos
0,25 = 1 · 4−1 = (0,1)4 .
Logo, (101,01)2 = (11,1)4 . Verifique estas contas no computador! ♦

Licença CC-BY-SA-3.0. Contato: [email protected]

2.1. SISTEMA DE NUMERAÇÃO E MUDANÇA DE BASE 9

Exercícios

E 2.1.1. Converta para base decimal cada um dos seguintes números:

a) (100)2

b) (100)3

c) (100)b

d) (12)5

e) (AA)16

f) (7,1)8

g) (3,12)5

E 2.1.2. Escreva os números abaixo na base decimal.

a) (25,13)8

b) (101,1)2

c) (12F,4)16

d) (11,2)3

E 2.1.3. Escreva o número 5,5 em base binária.

E 2.1.4. Escreva o número 17,109375 em base hexadecimal (b = 16).

E 2.1.5. Escreva cada número decimal na base b.

a) 7,6 na base b = 5

b) 29,16 na base b = 6

E 2.1.6. Escreva (12.4)8 em base decimal e binária.

E 2.1.7. Escreva cada número dado para a base b.

a) (45,1)8 para a base b = 2

Licença CC-BY-SA-3.0. Contato: [email protected]

 10 Cálculo Numérico

b) (21,2)8 para a base b = 16

c) (1001,101)2 para a base b = 8
d) (1001,101)2 para a base b = 16

E 2.1.8. Quantos algarismos são necessários para representar o número 937163832173947

em base binária? E em base 7? Dica: Qual é o menor e o maior inteiro que pode
ser escrito em dada base com N algarismos?

2.2 Notação científica e notação normalizada

Como vimos, no sistema posicional usual um número x na base b é representado
por
x = ±(dn dn−1 · · · d0 ,d−1 d−2 d−3 · · · )b ,
onde dn 6= 0 e di ∈ {0, 1, . . . , b − 1} é o dígito da i-ésima posição. Alternativa-
mente, é costumeiro usarmos a chamada notação científica. Nesta, o número x é
representado como
x = ±(M )b × be ,
onde (M )b = (dm dm−1 · · · d0 ,d−1 d−2 d−3 · · · )b é chamada de mantissa e e ∈ Z é
chamado de expoente de x.
Exemplo 2.2.1. a) O número 602,2141 em notação científica pode ser escrito
como
602,2141 × 100 = 60,22141 × 101 = 0,6022141 × 103 .

b) O número (1010,10)2 pode ser escrito em notação científica como (10,1010)2 ×

22 .
Observamos que um número pode ser representado de várias formas equivalen-
tes em notação científica. Para termos uma representação única introduzimos o
conceito de notação normalizada.
Definição 2.2.1. Um número x na base b é dito estar representado em notação
(científica) normalizada quando está escrito na forma

x = (−1)s (M )b × bE ,

onde (M )b = (d1 ,d−1 d−2 d−3 · · · )b , com d1 6= 034 , s é 0 para positivo e 1 para
negativo, E é o expoente.
3
Em algumas referências é usado Mb = (0,d−1 d−2 d−3 ·)b .
4
No caso de x = 0, Mb = (0,00 · · · )b .

Licença CC-BY-SA-3.0. Contato: [email protected]

2.3. REPRESENTAÇÃO DECIMAL FINITA 11

Exemplo 2.2.2. Vejamos os seguintes casos:

a) O número 602,2141 em notação (científica) normalizada é representado por
6,022141 × 102 .
b) O número (1010,10)2 escrito em notação normalizada é (1,01010)2 × 23 .
Observação 2.2.1. Em Python, podemos controlar a impressão de números usando
o comando print. Por exemplo:
>>> print("%1.5f" % -np.pi)
-3.14159
>>> print("%1.5e" % -np.pi)
-3.14159e+00
No primeiro caso, obtemos a representação em ponto flutuante decimal com 6
dígitos do número −π. No segundo caso, obtemos a representação em notação
científica normalizada com 6 dígitos.

2.2.1 Exercícios

E 2.2.1. Represente os seguintes números em notação científica normalizada:

a) 299792,458 b) 66,2607 × 10−35

c) 0,6674 × 10−7 d) 9806,65 × 101

E 2.2.2. Use o computador para verificar as respostas do Exercício 2.2.1.

2.3 Representação decimal finita

Em computadores, é usual representarmos números usando uma quantidade
de dígitos finita. A quantidade a ser usada normalmente depende da precisão
com que as computações estão sendo feitas. Ocorre, que quando restringimos
a representação a um número finito de dígitos, muitos números não podem ser
representado de forma exata. Por exemplo, dízimas infinitas e números irracionais
não são usualmente representados de forma exata em computadores. Esta questão
nos leva aos conceitos de número de dígitos significativos e arredondamento.
Definição 2.3.1 (Número de dígitos significativos). Um número decimal x =
±d1 ,d−1 · · · d−i d−i−1 · · · d−i−n d−i−n−1 ·×10E é dito ter n dígitos significativos quando
dj = 0 para j ≥ −i e j ≤ −i − n − 1.
Exemplo 2.3.1. O número 0,0602100 × 10−3 tem 4 dígitos significativos.

Licença CC-BY-SA-3.0. Contato: [email protected]

 12 Cálculo Numérico

2.3.1 Arredondamento de números

Quando representamos um número x com uma quantidade de dígitos menor
que a de dígitos significativos acabamos com uma aproximação deste. Este pro-
cedimento é chamado arredondamento de um número. Mais precisamente, seja
dado
x = ±d0 ,d1 d2 . . . dk−1 dk dk+1 . . . dn × 10e
em notação normalizada, i.e. d0 6= 0. Podemos representar x com k dígitos
fazendo:
1. Arredondamento por truncamento (ou corte): aproximamos x por

x̄ = ±d0 ,d1 d2 . . . dk × 10e

simplesmente descartando os dígitos dj com j > k.

2. Arredondamento por proximidade: se dk+1 < 5 aproximamos x por

x̄ = ±d0 ,d1 d2 . . . dk × 10e

senão aproximamos x por5

x̄ = ±(d0 ,d1 d2 . . . dk + 10−k ) × 10e

Exemplo 2.3.2. Represente os números x1 = 0,567, x2 = 0,233, x3 = −0,675

e x4 = 0,314159265 . . . × 101 com dois dígitos significativos por truncamento e
arredondamento.
Solução. Vejamos cada caso:
• Por truncamento:

x1 = 0,56, x2 = 0,23, x3 = −0,67 e x4 = 3,1.

Em Python, podemos obter a representação de x3 = −0,675 fazendo:

>>> int(-0.675*1e2)/1e2

e, em notação normalizada, temos:

5
Note que essas duas opções são equivalentes a somar 5 no dígito a direita do corte e depois
arredondar por corte, ou seja, arredondar por corte

±(d0 ,d1 d2 . . . dk dk+1 + 5 × 10−(k+1) ) × 10e

Licença CC-BY-SA-3.0. Contato: [email protected]

2.4. REPRESENTAÇÃO DE NÚMEROS EM MÁQUINA 13

>>> print("%1.1e" % (int(-0.675*1e2)/1e2))

-6.7e-01

• Por arredondamento:

x1 = 0,57; x2 = 0,23; x3 = −0,68 e x4 = 3,1.

Em Python, a representação de números por arredondamento é o padrão.

Assim, para obtermos a representação desejada de x3 = 0,675 fazemos:

>>> print("%1.2f" % (-0.675))

-0.68

e, em notação normalizada:

>>> print("%1.1e" % (-0.675))

-6.8e-01

Observação 2.3.1. Observe que o arredondamento pode mudar todos os dígitos e

o expoente da representação em ponto flutuante de um número dado. Por exemplo,
o arredondamento de 0,9999 × 10−1 com 3 dígitos significativos é 0,1 × 100 .

2.4 Representação de números em máquina

Os computadores, em geral, usam a base binária para representar os números,
onde as posições, chamadas de bits, assume as condições “verdadeiro” ou “falso”,
ou seja, 1 ou 0, respectivamente. Os computadores representam os números com
uma quantidade fixa de bits, o que se traduz em um conjunto finito de números re-
presentáveis. Os demais números são tomados por proximidade àqueles conhecidos,
gerando erros de arredondamento. Por exemplo, em aritmética
√ de computador, o
número 2 tem representação
√ 2 exata, logo 22
= 4, mas 3 não tem representação
finita, logo ( 3) 6= 3.
Veja isso em Python:

>>> 2**2 == 4
True
>>> np.sqrt(3)**2 == 3
False

Licença CC-BY-SA-3.0. Contato: [email protected]

 14 Cálculo Numérico

2.4.1 Números inteiros

Tipicamente, um número inteiro é armazenado em um computador como uma

sequência de dígitos binários de comprimento fixo denominado registro.

Representação sem sinal

Um registro com n bits da forma

dn−1 dn−2 ··· d1 d0

representa o número (dn−1 dn−2 ...d1 d0 )2 .

Assim, é possível representar números inteiros entre 2n − 1 e 0, sendo

[111 . . . 111] = 2n−1 + 2n−2 + · · · + 21 + 20 = 2n − 1,

..
.
[000 . . . 011] = 3,
[000 . . . 010] = 2,
[000 . . . 001] = 1,
[000 . . . 000] = 0.

Representação com bit de sinal

O bit mais significativo (o primeiro à esquerda) representa o sinal: por conven-

ção, 0 significa positivo e 1 significa negativo. Um registro com n bits da forma

s dn−2 ··· d1 d0

representa o número (−1)s (dn−2 . . . d1 d0 )2 . Assim, é possível representar números

inteiros entre −2n−1 e 2n−1 , com duas representações para o zero: (1000 . . . 000)2
e (00000 . . . 000)2 .

Licença CC-BY-SA-3.0. Contato: [email protected]

2.4. REPRESENTAÇÃO DE NÚMEROS EM MÁQUINA 15

Exemplo 2.4.1. Em um registro com 8 bits, teremos os números

[11111111] = −(26 + · · · + 2 + 1) = −127,

..
.
[10000001] = −1,
[10000000] = −0,
[01111111] = 26 + · · · + 2 + 1 = 127,
..
.
[00000010] = 2,
[00000001] = 1,
[00000000] = 0.

Representação complemento de dois

O bit mais significativo (o primeiro à esquerda) representa o coeficiente de

−2 . Um registro com n bits da forma:
n−1

dn−1 dn−2 ··· d1 d0

representa o número −dn−1 2n−1 + (dn−2 . . . d1 d0 )2 .

Observação 2.4.1. Note que todo registro começando com 1 será um número
negativo.

Exemplo 2.4.2. O registro com 8 bits [01000011] representa o número:

−0(27 ) + (1000011)2 = 26 + 2 + 1 = 67.

Agora, o registro [10111101] representa:

−1(27 ) + (0111101)2 = −128 + 25 + 24 + 23 + 22 + 1 = −67.

Note que podemos obter a representação de −67 invertendo os dígitos de 67 em

binário e somando 1.

Licença CC-BY-SA-3.0. Contato: [email protected]

 16 Cálculo Numérico

Exemplo 2.4.3. Em um registro com 8 bits, teremos os números

[11111111] = −27 + 26 + · · · + 2 + 1 = −1
..
.
[10000001] = −27 + 1 = −127
[10000000] = −27 = −128
[01111111] = 26 + · · · + 2 + 1 = 127
..
.
[00000010] = 2
[00000001] = 1
[00000000] = 0

2.4.2 Sistema de ponto fixo

O sistema de ponto fixo representa as partes inteira e fracionária do número
com uma quantidade fixas de dígitos.

Exemplo 2.4.4. Em um computador de 32 bits que usa o sistema de ponto fixo,

o registro

d31 d30 d29 ··· d1 d0

pode representar o número

• (−1)d31 (d30 d29 · · · d17 d16 , d15 d14 · · · d1 d0 )2 se o sinal for representado por um
dígito. Observe que nesse caso o zero possui duas representações possíveis:

[10000000000000000000000000000000]

e
[00000000000000000000000000000000]

• (d30 d29 · · · d17 d16 )2 − d31 (215 − 2−16 ) + (0,d15 d14 · · · d1 d0 )2 se o sinal do nú-
mero estiver representado por uma implementação em complemento de um.
Observe que o zero também possui duas representações possíveis:

[11111111111111111111111111111111]

e
[00000000000000000000000000000000]

Licença CC-BY-SA-3.0. Contato: [email protected]

2.4. REPRESENTAÇÃO DE NÚMEROS EM MÁQUINA 17

• (d30 d29 · · · d17 d16 )2 − d31 215 + (0,d15 d14 · · · d1 d0 )2 se o sinal do número estiver
representado por uma implementação em complemento de dois. Nesse caso
o zero é unicamente representado por
[00000000000000000000000000000000]

Observe que 16 dígitos são usados para representar a parte fracionária, 15 são para
representar a parte inteira e um dígito, o d31 , está relacionado ao sinal do número.

2.4.3 Sistema de ponto flutuante

O sistema de ponto flutuante não possui quantidade fixa de dígitos para as
partes inteira e fracionária do número.
Podemos definir uma máquina F em ponto flutuante de dois modos:
F (β,|M |,|E|,BIAS) ou F (β,|M |,EM IN ,EM AX )
onde
• β é a base (em geral 2 ou 10),
• |M | é o número de dígitos da mantissa,
• |E| é o número de dígitos do expoente,
• BIAS é um valor de deslocamento do expoente (veja a seguir),
• EM IN é o menor expoente,
• EM AX é o maior expoente.
Considere uma máquina com um registro de 64 bits e base β = 2. Pelo padrão
IEEE754, 1 bit é usado para o sinal, 11 bits para o expoente e 52 bits são usados
para o significando tal que

s c10 c9 ··· c0 m1 m2 ··· m51 m52

represente o número (o BIAS = 1023 por definição)

x = (−1)s M × 2c−BIAS ,
onde a característica é representada por
c = (c10 c9 · · · c1 c0 )2 = c10 210 + · · · + c1 21 + c0 20
e o significando por
M = (1.m1 m2 · · · m51 m52 )2 .

Licença CC-BY-SA-3.0. Contato: [email protected]

 18 Cálculo Numérico

Observação 2.4.2. Em base 2 não é necessário armazenar o primeiro dígito (por

quê?).
Exemplo 2.4.5. O registro

[0|100 0000 0000|1010 0000 0000 . . . 0000 0000]

representa o número

(−1)0 (1 + 2−1 + 2−3 ) × 21024−1023 = (1 + 0.5 + 0.125)2 = 3.25.

O expoente deslocado
Uma maneira de representar os expoentes inteiros é deslocar todos eles uma
mesma quantidade. Desta forma permitimos a representação de números negativos
e a ordem deles continua crescente. O expoente é representado por um inteiro sem
sinal do qual é deslocado o BIAS.
Tendo |E| dígitos para representar o expoente, geralmente o BIAS é predefi-
nido de tal forma a dividir a tabela ao meio de tal forma que o expoente um seja
representado pelo sequência [100 . . . 000].
Exemplo 2.4.6. Com 64 bits, pelo padrão IEEE754, temos que |E| := 11. As-
sim, (100 0000 0000)2 = 210 = 1024. Como queremos que esta sequência represente
o 1, definimos BIAS := 1023, pois

1024 − BIAS = 1.

Com 32 bits, temos |E| := 8 e BIAS := 127. E com 128 bits, temos |E| := 15
e BIAS := 16383.
Com |E| = 11 temos
[111 1111 1111] = reservado
[111 1111 1110] = 2046 − BIAS = 102310 = EM AX
..
.=
[100 0000 0001] = 210 + 1 − BIAS = 210
[100 0000 0000] = 210 − BIAS = 110
[011 1111 1111] = 1023 − BIAS = 010
[011 1111 1110] = 1022 − BIAS = −110
..
.=
[000 0000 0001] = 1 − BIAS = −1022 = EM IN
[000 0000 0000] = reservado

Licença CC-BY-SA-3.0. Contato: [email protected]

2.4. REPRESENTAÇÃO DE NÚMEROS EM MÁQUINA 19

O maior expoente é dado por EM AX = 1023 e o menor expoente é dado por

EM IN = −1022.
O menor número representável positivo é dado pelo registro
[0|000 0000 0001|0000 0000 0000 . . . 0000 0000]
quando s = 0, c = 1 e M = (1.000...000)2 , ou seja,
M IN R = (1 + 0)2 × 21−1023 ≈ 0.2225 × 10−307 .
O maior número representável é dado por
[0|111 1111 1110|1111 1111 · · · 1111 1111]
quando s = 0, c = 2046 e M = (1.1111 1111 · · · 1111)2 = 2 − 2−52 , ou seja,
M AXR = (2 − 2−52 ) × 22046−1023 ≈ 21024 ≈ 0.17977 × 10309 .
Observação 2.4.3. Em Python, podemos podemos obter o maior e o menor
double positivo não nulo com os comandos:
>>> import sys
>>> sys.float_info.max
1.7976931348623157e+308
>>> sys.float_info.min
2.2250738585072014e-308
Outras informações sobre a representação em ponto flutuante podem ser obtidas
com sys.float_info.

Casos especiais
O zero é um caso especial representado pelo registro
[0|000 0000 0000|0000 0000 0000...0000 0000]
Os expoentes reservados são usados para casos especiais:
• c = [0000...0000] é usado para representar o zero (se m = 0) e os números
subnormais (se m 6= 0).
• c = [1111...1111] é usado para representar o infinito (se m = 0) e NaN (se
m 6= 0).
Os números subnormais6 tem a forma
x = (−1)s (0.m1 m2 · · · m51 m52 )2 × 21−BIAS .
6
Note que poderíamos definir números um pouco menores que o M IN R.

Licença CC-BY-SA-3.0. Contato: [email protected]

 20 Cálculo Numérico

2.4.4 Precisão e épsilon de máquina

A precisão p de uma máquina é o número de dígitos significativos usado para
representar um número. Note que p = |M | + 1 em binário e p = |M | para outras
bases.
O épsilon de máquina, mach = , é definido de forma que 1 +  seja o menor
número representável maior que 1, isto é, 1 +  é representável, mas não existem
números representáveis em (1, 1 + ).

Exemplo 2.4.7. Com 64 bits, temos que o épsilon será dado por

1 → (1.0000 0000....0000)2 × 20
 → +(0.0000 0000....0001)2 × 20 = 2−52
(1.0000 0000....0001)2 × 20 6= 1

Assim,  = 2−52 .

Em Python, podemos obter o épsilon de máquina com os comandos:

>>> import sys

>>> sys.float_info.epsilon
2.220446049250313e-16

Observe, também, os seguintes resultados:

>>> eps = sys.float_info.epsilon

>>> 1 + 1e-16 == 1
True
>>> 1 + eps == 1
False

2.4.5 Distribuição dos números

Utilizando uma máquina em ponto flutuante, temos um número finito de nú-
meros que podemos representar.
Um número muito pequeno geralmente é aproximado por zero (underflow) e
um número muito grande (overflow) geralmente faz o cálculo parar. Além disso,
os números não estão uniformemente espaçados no eixo real. Números pequenos
estão bem próximos enquanto que números com expoentes grandes estão bem
distantes.
Se tentarmos armazenar um número que não é representável, devemos utilizar
o número mais próximo, gerando os erros de arredondamento.

Licença CC-BY-SA-3.0. Contato: [email protected]

2.5. TIPOS DE ERROS 21

Exercícios

E 2.4.1. Usando a representação complemento de dois de números inteiros

com 8 bits, escreva o número decimal que corresponde aos seguintes barramentos:
a) [01100010].
b) [00011101].
c) [11100011].

E 2.4.2. Usando a representação complemento de dois de números inteiros

com 16 bits, escreva o número decimal que corresponde aos seguintes barramentos:
a) [0110001001100010].
b) [0001110100011101].
c) [1110001011100011].

E 2.4.3. Usando a representação de ponto flutuante com 64 bits, escreva o

número decimal que corresponde aos seguintes barramentos:
a) [0|10000000000|111000 . . . 0].
b) [1|10000000001|0111000 . . . 0].

E 2.4.4. Explique a diferença entre o sistema de ponto fixo e ponto flutuante.

2.5 Tipos de erros

Em geral, os números não são representados de forma exata nos computadores.
Isto nos leva ao chamado erro de arredondamento. Quando resolvemos problemas
com técnicas numéricas estamos sujeitos