Cálculo Numérico

Um Livro Colaborativo
Versão Octave

23 de maio 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
GNU Octave para a implementação dos métodos numéricos abordados. Recomen-
damos ao leitor ter à sua disposição um computador com o GNU Octave (versão 4.0
ou superior) instalado. 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. Veja, por exemplo, o SageMathCloud e o Octave Online.
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Representação decimal finita . . . . . . . . . . . . . . . . . . . . . . 12
2.3.1 Arredondamento de números . . . . . . . . . . . . . . . . . . 12
2.4 Representação de números em máquina . . . . . . . . . . . . . . . . 14
2.4.1 Números inteiros . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.2 Sistema de ponto fixo . . . . . . . . . . . . . . . . . . . . . . 17
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 . . . . . . . . . . . . . . . . . . . . 21
2.5 Tipos de erros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.6 Erros nas operações elementares . . . . . . . . . . . . . . . . . . . . 27
2.7 Cancelamento catastrófico . . . . . . . . . . . . . . . . . . . . . . . 27
2.8 Condicionamento de um problema . . . . . . . . . . . . . . . . . . . 30
2.9 Mais exemplos de cancelamento catastrófico . . . . . . . . . . . . . 35

vi
SUMÁRIO vii

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

3.1 Existência e unicidade . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.2 Método da bisseção . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.2.1 Código GNU Octave: método da bisseção . . . . . . . . . . 52
3.3 Iteração de ponto fixo . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.3.1 Teorema do ponto fixo . . . . . . . . . . . . . . . . . . . . . 58
3.3.2 Teste de convergência . . . . . . . . . . . . . . . . . . . . . . 62
3.3.3 Estabilidade e convergência . . . . . . . . . . . . . . . . . . 63
3.3.4 Erro absoluto e tolerância . . . . . . . . . . . . . . . . . . . 64
3.4 Método de Newton-Raphson . . . . . . . . . . . . . . . . . . . . . . 70
3.4.1 Interpretação geométrica . . . . . . . . . . . . . . . . . . . . 71
3.4.2 Análise de convergência . . . . . . . . . . . . . . . . . . . . 72
3.5 Método das secantes . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3.5.1 Interpretação geométrica . . . . . . . . . . . . . . . . . . . . 78
3.5.2 Análise de convergência . . . . . . . . . . . . . . . . . . . . 79
3.6 Critérios de parada . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
3.7 Exercícios finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

4 Solução de sistemas lineares 89

4.1 Eliminação gaussiana . . . . . . . . . . . . . . . . . . . . . . . . . . 91
4.1.1 Eliminação gaussiana com pivotamento parcial . . . . . . . . 96
4.2 Complexidade de algoritmos em álgebra linear . . . . . . . . . . . . 103
4.3 Sistemas triangulares . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4.4 Fatoração LU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
4.4.1 Código GNU Octave: Fatoração LU . . . . . . . . . . . . . . 108
4.4.2 Custo computacional para resolver um sistema linear usando
fatoração LU . . . . . . . . . . . . . . . . . . . . . . . . . . 108
4.4.3 Custo para resolver m sistemas lineares . . . . . . . . . . . . 109
4.4.4 Custo para calcular a matriz inversa de A . . . . . . . . . . 110
4.5 Método da matriz tridiagonal . . . . . . . . . . . . . . . . . . . . . 110
4.6 Condicionamento de sistemas lineares . . . . . . . . . . . . . . . . . 117
4.6.1 Norma de vetores . . . . . . . . . . . . . . . . . . . . . . . . 118
4.6.2 Norma de matrizes . . . . . . . . . . . . . . . . . . . . . . . 119
4.6.3 Número de condicionamento . . . . . . . . . . . . . . . . . . 120
4.7 Métodos iterativos para sistemas lineares . . . . . . . . . . . . . . . 123
4.7.1 Método de Jacobi . . . . . . . . . . . . . . . . . . . . . . . . 123
4.7.2 Método de Gauss-Seidel . . . . . . . . . . . . . . . . . . . . 125
4.7.3 Análise de convergência . . . . . . . . . . . . . . . . . . . . 127
4.8 Cálculo de autovalores e autovetores . . . . . . . . . . . . . . . . . 135
4.8.1 Método da Potência . . . . . . . . . . . . . . . . . . . . . . 135
4.8.2 Método da iteração Inversa . . . . . . . . . . . . . . . . . . 139

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

 viii Cálculo Numérico

4.9 Exercícios finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

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

5.1 Método de Newton para sistemas . . . . . . . . . . . . . . . . . . . 146
5.1.1 Código GNU Octave: Newton para sistemas . . . . . . . . . 149
5.2 Linearização de uma função de várias variáveis . . . . . . . . . . . . 157
5.2.1 Gradiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
5.2.2 Matriz jacobiana . . . . . . . . . . . . . . . . . . . . . . . . 158

6 Interpolação 161
6.1 Interpolação polinomial . . . . . . . . . . . . . . . . . . . . . . . . . 162
6.2 Diferenças divididas de Newton . . . . . . . . . . . . . . . . . . . . 166
6.3 Polinômios de Lagrange . . . . . . . . . . . . . . . . . . . . . . . . 168
6.4 Aproximação de funções reais por polinômios interpoladores . . . . 169
6.5 Interpolação linear segmentada . . . . . . . . . . . . . . . . . . . . 172
6.6 Interpolação cúbica segmentada - spline . . . . . . . . . . . . . . . . 173
6.6.1 Spline natural . . . . . . . . . . . . . . . . . . . . . . . . . . 176
6.6.2 Spline fixado . . . . . . . . . . . . . . . . . . . . . . . . . . 178
6.6.3 Spline not-a-knot . . . . . . . . . . . . . . . . . . . . . . . . 179
6.6.4 Spline periódico . . . . . . . . . . . . . . . . . . . . . . . . . 180

7 Ajuste de curvas 182

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

8 Derivação Numérica 202

8.1 Diferenças finitas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
8.1.1 Diferenças finitas via série de Taylor . . . . . . . . . . . . . 204
8.1.2 Erros de arredondamento . . . . . . . . . . . . . . . . . . . . 208
8.2 Diferença finita para derivada segunda . . . . . . . . . . . . . . . . 212
8.3 Diferenças finitas de ordem mais alta . . . . . . . . . . . . . . . . . 212
8.4 Fórmulas de diferenças finitas . . . . . . . . . . . . . . . . . . . . . 215
8.5 Derivada via ajuste ou interpolação . . . . . . . . . . . . . . . . . . 218
8.6 Exercícios finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

9 Integração Numérica 220

9.1 Regras de Newton-Cotes . . . . . . . . . . . . . . . . . . . . . . . . 222
9.1.1 Somas de Riemann . . . . . . . . . . . . . . . . . . . . . . . 223
9.1.2 Regra do trapézio . . . . . . . . . . . . . . . . . . . . . . . . 223

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

SUMÁRIO ix

9.1.3 Regra de Simpson . . . . . . . . . . . . . . . . . . . . . . . . 226

9.2 Obtenção das regras de quadratura . . . . . . . . . . . . . . . . . . 229
9.3 Regras compostas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
9.3.1 Método composto dos trapézios . . . . . . . . . . . . . . . . 232
9.3.2 Código GNU Octave: trapézio composto . . . . . . . . . . . 232
9.3.3 Método composto de Simpson . . . . . . . . . . . . . . . . . 233
9.3.4 Código em GNU Octave: Simpson composto . . . . . . . . . 233
9.4 O método de Romberg . . . . . . . . . . . . . . . . . . . . . . . . . 236
9.5 Ordem de precisão . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
9.6 Quadratura de Gauss-Legendre . . . . . . . . . . . . . . . . . . . . 244
9.7 Exercícios finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

10 Problemas de valor inicial 252

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

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

 x Cálculo Numérico

10.17.1 Método 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

10.17.2 Método 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
10.18Sistemas de equações diferenciais e equações de ordem superior . . . 278
10.19Exercícios finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

11 Problemas de Valores de Contorno 284

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

A Rápida Introdução ao GNU Octave 295

A.1 Sobre o GNU Octave . . . . . . . . . . . . . . . . . . . . . . . . . . 295
A.2 Instalação e Execução . . . . . . . . . . . . . . . . . . . . . . . . . 295
A.3 Usando o GNU Octave . . . . . . . . . . . . . . . . . . . . . . . . . 296
A.4 Elementos da linguagem . . . . . . . . . . . . . . . . . . . . . . . . 297
A.4.1 Operações matemáticas elementares . . . . . . . . . . . . . . 297
A.4.2 Funções e constantes elementares . . . . . . . . . . . . . . . 298
A.4.3 Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . 298
A.5 Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
A.5.1 O operador “:” . . . . . . . . . . . . . . . . . . . . . . . . . 299
A.5.2 Obtendo dados de uma matriz . . . . . . . . . . . . . . . . . 300
A.5.3 Operações matriciais e elemento-a-elemento . . . . . . . . . 301
A.6 Estruturas de ramificação e repetição . . . . . . . . . . . . . . . . . 302
A.6.1 A instrução de ramificação “if” . . . . . . . . . . . . . . . . 302
A.6.2 A instrução de repetição “for” . . . . . . . . . . . . . . . . . 303
A.6.3 A instrução de repetição “while” . . . . . . . . . . . . . . . . 304
A.7 Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
A.8 Gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

Respostas dos Exercícios 307

Referências Bibliográficas 322

Colaboradores 323

Índice Remissivo 324

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.

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 .
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
±, 0, 1, 2, . . . , b − 11}1 , a sequência de símbolos
b > 1 e o conjunto de símbolos {±
(dn dn−1 · · · d1 d0 ,d−1 d−2 · · · )b
1
Para b > 10, veja a observação 2.1.1.

3
 4 Cálculo Numérico

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.
No GNU Octave podemos converter o número (1001,101)2 para a base decimal
computando
>> 1*2^3 + 0*2^2 + 0*2^1 + 1*2^0 + 1*2^-1 + 0*2^-2 + 1*2^-3
ans = 9.6250
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!
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.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. O GNU Octave oferece algumas funções para a conversão de

números inteiros em dada base para a base decimal. Por exemplo, temos:

>> bin2dec('1001')
ans = 9
>> hex2dec('451')
ans = 1105
>> base2dec('157',8) #oct -> dec
ans = 111
>> base2dec('BEBA',16)
ans = 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

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
Licença CC-BY-SA-3.0. Contato: [email protected]
 6 Cálculo Numérico

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 . No GNU Octave, podemos usar os comandos fix
(truncamento) e mod (resto da divisão) para computar esta conversão da seguinte
forma
>> x = 9
x = 9
>> d0 = mod(x,2), x = fix(x/2)
d0 = 1
x = 4
>> d1 = mod(x,2), x = fix(x/2)
d1 = 0
x = 2
>> d2 = mod(x,2), x = fix(x/2)
d2 = 0
x = 1
>> d3 = mod(x,2), x = fix(x/2)
d3 = 1
x = 0

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

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

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 . No GNU Octave, podemos computar esta
conversão da parte fracionária da seguinte forma

>> x = 0.625
x = 0.62500
>> d = fix(2*x), x = 2*x - d
d = 1
x = 0.25000
>> d = fix(2*x), x = 2*x - d
d = 0
x = 0.50000
>> d = fix(2*x), x = 2*x - d
d = 1
x = 0

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. O GNU Octave oferece algumas funções para a conversão de

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

>> dec2base(9,2)
ans = 1001
>> dec2base(111,8)
ans = 157
>> dec2base(48826,16)
ans = BEBA

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 .

Exercícios resolvidos
ER 2.1.1. Obtenha a representação do número 125,583̄ na base 6.

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

 8 Cálculo Numérico

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 no GNU Octave com o auxílio das funções mod
e fix. A primeira calcula 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:
>> x = 125
x = 125
>> d = mod(x,6), x = fix(x/6)
d = 5
x = 20
>> d = mod(x,6), x = fix(x/6)
d = 2
x = 3
>> d = mod(x,6), x = fix(x/6)
d = 3
x = 0
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 . No GNU Octave, podemos computar esta conversão da parte
fracionária da seguinte forma
>> x = 0.58 + 1/3/100
x = 0.58333
>> d = fix(6*x), x = 6*x - d
d = 3
x = 0.50000
>> x = 0.5 #isso é realmente necessário?

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

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

x = 0.50000
>> d = fix(6*x), x = 6*x - d
d = 3
x = 0
♦

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! ♦

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

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

 10 Cálculo Numérico

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
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.

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

2.2. NOTAÇÃO CIENTÍFICA E NOTAÇÃO NORMALIZADA 11

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.

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. No GNU Octave, podemos controlar a impressão de números

usando o comando printf. Por exemplo:

>> printf('%1.5f\n',-pi)
-3.14159
>> printf('%1.5e\n',-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.
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]

 12 Cálculo Numérico

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.

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.

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

2.3. REPRESENTAÇÃO DECIMAL FINITA 13

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.

No GNU Octave, podemos obter a representação de x3 = −0,675 fazendo:

>> printf("%1.2f\n", ceil(-0.675*1e2)/1e2)

-0.67

e, em notação normalizada, temos:

>> printf("%1.1e\n", ceil(-0.675*1e2)/1e2)

-6.7e-01

• Por arredondamento:

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

Em GNU Octave, a representação de números por arredondamento é o pa-

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

>> printf("%1.2f\n", -0.675)

-0.68
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]

 14 Cálculo Numérico

e, em notação normalizada, temos:

>> printf("%1.1e\n", -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 exata, logo 2 = 4, mas 3 não tem representação
2

finita, logo ( 3)2 6= 3.

Veja isso no GNU Octave:

>> 2^2 == 4
ans = 1
>> sqrt(3)^2 == 3
ans = 0

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 .

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

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

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 .

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
−2n−1 . Um registro com n bits da forma:

dn−1 dn−2 ··· d1 d0

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

 16 Cálculo Numérico

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.
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
O GNU Octave trabalha com representação complemento de 2 de números in-
teiros. O comando bitunpack mostra o barramento de um número dado, por
exemplo:
>> bitunpack(int8(3))
ans =
1 1 0 0 0 0 0 0
mostra o barramento com 8 bits do número inteiro 3. Note que a ordem dos bits
é inversa daquela apresentada no texto acima. Aqui, o bit mais a esquerda fornece
o coeficiente de 20 , enquando o bit mais a direita fornece o coeficiente de −27 .
O comando bitpack converte um barramento para o número em decimal, por
exemplo:
>> bitpack(logical([1 1 0 0 0 0 0 0]),'int8')
ans = 3

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

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

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]
• (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

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

 18 Cálculo Numérico

• β é 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 .
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.
Observação 2.4.3. No GNU Octave, podemos usar os comandos bitpack e bitunpack
transformar um registro de ponto flutuante de 64 bits em decimal e vice-e-versa.
Entretanto, um tal registro no GNU Octave tem a seguinte estrutura
[m52 m51 m50 . . . m1 |c0 c1 c2 · · · c10 |s].
Desta forma, o decimal 3.25 tem, aqui, o registro
[000 . . . 0101|000 . . . 01|0].
O que podemos verificar com o comando
>> bitpack(logical([zeros(1,49) 1 0 1 zeros(1,10) 1 0]),'double')
ans = 3.2500

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

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

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

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 .

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

 20 Cálculo Numérico

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.4. No GNU Octave, podemos obter o maior e o menor double

positivo não nulo com os comandos:

>> realmax
ans = 1.7977e+308
>> realmin
ans = 2.2251e-308

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 .

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 + ).
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]

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

Exemplo 2.4.7. Com 64 bits, temos que o épsilon será dado por
1 → (1.0000 0000....0000)2 × 20
 → +(0.0000 000