Copyright © 2018-2026 Carlos Wilson

Published by Publisher
ISBN 000-00-00-00000-0
[Link]

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this
file except in compliance with the License. You may obtain a copy of the License at
[Link] Unless required by applicable law or
agreed to in writing, software distributed under the License is distributed on an “AS IS”
BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied. See the License for the specific language governing permissions and limitations
under the License.

Livro em constante atualização.

Última atualização: 27 de abril de 2026 às 08:47.
Número de compilação: 6575
Prefácio
4
 Sumário

I Parte Um: Programação Python

1 Uma Introdução à Programação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1.1 O que é um Programa de Computador? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.2 Uma Breve História . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.3 Preparando no Ambiente Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.4 Preparando no Ambiente GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.5 Salvando seus Programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.6 Interpretador Python On-line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.7 Compreendendo os Erros de Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.8 Comentando Seus programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.9 Usando Comentários para Excluir Comandos do Programa . . . . . . . . . . . . . 22

2 IDE Python para Computação Científica . . . . . . . . . . . . . . . . . . . . . . . . 23

2.1 O que é uma IDE? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.2 IDE Python para Computação Científica . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3 Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1 Apresentando as Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2 Como Declarar uma Variável . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.3 Melhorando a Legibilidade do Seu Programa . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4 Usando Nomes Representativos para as Variáveis . . . . . . . . . . . . . . . . . . . . 26
3.5 Compreendendo as Palavras Reservadas em Python . . . . . . . . . . . . . . . . . . 27
3.6 Tipos de Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.6.1 Compreendendo as Variáveis do Tipo INT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.6.2 Compreendendo as Variáveis do Tipo FLOAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.6.3 Compreendendo os Problemas e Limitações do FLOAT . . . . . . . . . . . . . . . . . . . . . . . 30
3.6.4 Compreendendo as Variáveis do tipo STR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.6.5 Compreendendo as Variáveis do tipo BOOL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.6.6 Compreendendo as Variáveis do tipo COMPLEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.6.7 Compreendendo as Variáveis do tipo LIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.6.8 Compreendendo as Variáveis do tipo TUPLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.7 Como Identificar o Tipo de Variável . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.8 Conversão entre Tipos de Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.9 Operadores Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

4 Entrada e Saída de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4.1 Introdução a Função print() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2 Como Exibir na Tela um Texto Incluindo Aspas . . . . . . . . . . . . . . . . . . . . . . 37
4.3 Quebra de Linha Usando a Função print() . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.4 Como Exibir na Tela o Conteúdo de uma Variável . . . . . . . . . . . . . . . . . . . . 38
4.5 Usando a Função print() para Imprimir a Saída de Outra Função . . . . . . 39
4.6 Usando a Função print() com Múltiplos Argumentos . . . . . . . . . . . . . . . . 39
4.7 Como Usar a Função print() sem Quebra de Linha . . . . . . . . . . . . . . . . . . 40
4.8 Usando a Função print() com Marcador de Posição . . . . . . . . . . . . . . . . . 40
4.9 Exibindo Valores do Tipo int Usando print() . . . . . . . . . . . . . . . . . . . . . . . 41
4.10 Exibindo uma string Usando print() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.11 Exibindo Valores do Tipo float Usando print() . . . . . . . . . . . . . . . . . . . . . 42
4.12 Lendo uma Entrada de Dados com o Comando input() . . . . . . . . . . . . . . . 43

5 Matemática Com Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

5.1 O que é uma Biblioteca no Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.2 Importação de Bibliotecas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3 Operações Básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.4 Potenciação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.5 Radiciação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.6 Operações Inteiras e Arredondamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
5.7 Sequência das Operações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
5.8 Constantes Matemáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
5.9 Funções Trigonométricas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.10 Funções Logarítmicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.11 Valor Absoluto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5.12 Fatorial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

6 Controle de Fluxo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
6.1 Compreendendo o Teste Condicional IF . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
6.2 Efetuando Testes Relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
6.3 Testando a Igualdade e Diferença . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
6.4 Conectivos Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
6.5 Conectivo de Conjunção E (and) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
6.6 Conectivo de Disjunção OU (or) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
6.7 Estrutura condicional if-elif-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

7 Estruturas de Repetição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
7.1 Compreendendo as Estruturas de Repetição . . . . . . . . . . . . . . . . . . . . . . . . . 67
7.2 Estrutura de Repetição: o laço for com uso do range . . . . . . . . . . . . . . . . 68
7.3 Decrementando Valores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
7.4 Controlando o Incremento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
7.5 Laços for Aninhados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
7.6 Somatórios e sua Relação com Laços for . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
7.7 Laço for Aninhado e Somatórios Duplos . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
7.8 Repetindo Comandos Usando o Laço while . . . . . . . . . . . . . . . . . . . . . . . . . . 73
7.9 Compreendendo o Comando continue do Python . . . . . . . . . . . . . . . . . . . . 74
7.10 Compreendendo o Comando break do Python . . . . . . . . . . . . . . . . . . . . . . . 75

8 Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
8.1 Sintaxe de uma Função . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
8.2 Criando uma Função sem Parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
8.3 Criando uma Função com Um Parâmetro . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
8.4 Criando uma Função com Dois ou Mais Parâmetros . . . . . . . . . . . . . . . . . . 82
8.5 Criando uma Função Retornando Algum Valor . . . . . . . . . . . . . . . . . . . . . . . 83

9 Matrizes com NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

9.1 A biblioteca NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
9.2 Declarando uma Matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
9.3 Declarando uma Matriz com Elementos Iguais . . . . . . . . . . . . . . . . . . . . . . . 90
9.4 Gerando um Vetor de Números com Espaçamento Uniforme . . . . . . . . . . . 91
9.5 Obtendo Propriedades do Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
9.6 Acessando Elemento Diretamente do Array . . . . . . . . . . . . . . . . . . . . . . . . . 93
9.7 Acessando Elemento Por Fatiamento em Vetores . . . . . . . . . . . . . . . . . . . . 93
9.8 Acessando Elemento Por Fatiamento em Matrizes . . . . . . . . . . . . . . . . . . . . 94
9.9 Maximo e Minimo de Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
9.10 Operadores Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
9.11 Soma da Elementos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
9.12 Operações de Comparação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
9.13 Criando uma Matriz de Números Aleatórios . . . . . . . . . . . . . . . . . . . . . . . . . 98
9.14 Percorrendo uma Matriz Bidimensional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

10 Gráficos com Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

10.1 A biblioteca Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
10.2 Construindo um Gráfico de Duas Dimensões . . . . . . . . . . . . . . . . . . . . . . . 106
10.3 Detalhando as Informações no Gráfico . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
10.4 Renomeando a Biblioteca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
10.5 Inserindo Texto no Gráfico com text() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
10.6 Construindo Gráficos de Dispersão com scatter() . . . . . . . . . . . . . . . . . . 108
10.7 Personalização de Gráficos com [Link] . . . . . . . . . . . . . . . . . 109
10.8 Inserindo Comandos LATEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
10.9 Configurando Ambiente 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
10.10 Construindo um Gráfico de Três Dimensões . . . . . . . . . . . . . . . . . . . . . . . . 118
10.11 Gráfico de Dispersão 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
10.12 Plotagem de Superfície 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

II Parte Dois: Cálculo Numérico

11 Erros Numéricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
11.1 Fundamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
11.2 Representação de Ponto Flutuante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
11.3 O Padrão IEEE 745 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
11.4 Computadores e arquiteturas com precisão maior que 64 bits . . . . . . . . . 131
11.5 Tipos de Arredondamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
11.6 Tipos de Erros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
11.7 A Importância de Considerar Erros Numéricos . . . . . . . . . . . . . . . . . . . . . . 134

12 Raizes de uma Função . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

12.1 Fundamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
12.2 Métodos Gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
12.3 Método da Bisseção . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
12.4 Método da Falsa Posição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
12.5 Método da Secante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
12.6 Método da Secante Modificado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

13 Otimização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
13.1 Fundamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
13.2 Busca da Razão Áurea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
13.3 Interpolação Quadrática . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
14 Interpolação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
14.1 Fundamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
14.2 Operador de Diferenças Divididas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
14.3 Operador de Diferenças Divididas de Ordem 1 (ODD-1) . . . . . . . . . . . . . . 174
14.4 Operador de Diferenças Divididas de Ordem 2 (ODD-2) . . . . . . . . . . . . . . 176
14.5 Operador de Diferenças Divididas de Ordem 3 (ODD-3) . . . . . . . . . . . . . . 177
14.6 Forma Geral da Diferença Dividida (ODD-m) . . . . . . . . . . . . . . . . . . . . . . . 178
14.7 Implementação da Diferença Dividida (Ordem m) . . . . . . . . . . . . . . . . . . . 179
14.8 Interpolação de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
14.9 Interpolação de Lagrange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

15 Sistemas de Equações Lineares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

15.1 Resolução de Sistemas Lineares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
15.2 Método de Jacobi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
15.3 Método de Gauss-Seidel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

16 Integração Numérica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

16.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
16.2 Fundamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
16.3 Fórmulas de Integração de Newton-Cotes . . . . . . . . . . . . . . . . . . . . . . . . . . 201
16.4 Método dos Trapézios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
16.5 Método dos Trapezios Composto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
16.6 Método de Simpson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
16.6.1 Método de Simpson 1/3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
16.7 Método de Simpson 1/3 Composta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

17 Derivação Numérica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213

17.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213

Bibliography . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

18 Solução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
 Lista de Figuras

1.1 Guido van Rossum. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

1.2 Usando o Ambiente IDLE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

9.1 Histogramas comparativos de 1000 valores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

9.2 Percurso em uma matriz bidimensional utilizando dois laços for aninhados. As setas representam
a ordem de varredura linha a linha, com índices iniciando em (0, 0). . . . . . . . . . . . . . . . . . . . . 100

10.1 O método plot() é utilizado para criar gráficos de linhas. No gráfico gerado, os meses são
representados na parte horizontal, correspondendo ao eixo X, enquanto os valores são posicionados na
parte vertical, representando o eixo Y . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
10.2 O método title(), xlabel() e ylabel() tornam o gráfico mais informativo. . . . . . . . . . . . . . 107
10.3 Comando text() com diversos parâmetros opcionais. . . . . . . . . . . . . . . . . . . . . . . . . . 109
10.4 oi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
10.5 Exemplos de personalização de gráficos com Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . 113
10.6 Duas imagens empilhadas em uma única coluna. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
10.7 Imagem produzida pelo programa [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . 119
10.8 Geração das matrizes X e Y com a função [Link](), a partir de vetores unidimensionais de
entrada. A matriz X contém, em cada linha, cópias do vetor de entrada x, enquanto a matriz Y contém,
em cada coluna, cópias do vetor de entrada y. Essas matrizes representam a malha de coordenadas no
plano XY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
p 
10.9 Gráfico de superfície da função z = sin x2 + y 2 , gerado pela função plot_surface() e
mapa de cores "jet". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

11.1 Explosão foquete Ariane 5 devido a um overflow. . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

12.1 Método da bisseção. São mostrados os pontos do intervalo [xa ,xb ] (vermelho) e o ponto médio
xc (azul). O intervalo é atualizado até uma aproximação suficiente da raiz. . . . . . . . . . . . . . . . 145
12.2 Método da Falsa Posição. São mostrados os pontos do intervalo [xa ,xb ] (vermelho) e o ponto
xr , que intercepta o eixo x (azul). O intervalo é atualizado até uma aproximação suficiente da raiz. 148
12.3 Aplicação do método da Secante à função x2 − 3x − 2 ao longo de 6 iterações . . . . . . . . 150

13.1 Representação gráfica do método da Razão Áurea em uma função unidimensional. . . . . . 161
13.2 Figura principal com três subfiguras organizadas em 3 linhas e 1 coluna. . . . . . . . . . . . . . 164
13.3 Evolução do erro absoluto ao longo de 20 iterações. As subfiguras (a) e (b) ilustram a aplicação
do método para localização do mínimo (Figura 13.2c), enquanto as subfiguras (c) e (d) mostram
sua aplicação para a localização do máximo (Figura 13.2c). Observe que o método da interpolação
quadrática pode apresentar instabilidades ao longo das iterações. . . . . . . . . . . . . . . . . . . . . . . 166

14.1 Representação geométrica das diferenças divididas de ordem zero e primeira. O ponto (x0 , f (x0 ))
representa a avaliação da função (ordem zero), enquanto a reta secante entre (x0 , f (x0 )) e (x1 , f (x1 ))
representa a diferença dividida de ordem um, dada por f [x0 , x1 ]. . . . . . . . . . . . . . . . . . . . . . . 175
14.2 Representação Geométrica da Diferença Dividida de Segunda Ordem . . . . . . . . . . . . . . . 177
14.3 Representação Geométrica da Diferença Dividida de Terceira Ordem . . . . . . . . . . . . . . . 178
sin(5x)
14.4 Comparação entre a função original f (x) = 1+25x 2 (linha azul), os pontos discretos utilizados
na interpolação de Newton (marcadores vermelhos) e a função interpolada resultante (linha vermelha
tracejada). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
sin(5x)
14.5 Gráfico da função original f (x) = 1+25x 2 (linha azul), com os pontos discretos usados na

interpolação (pontos vermelhos) e a curva do erro absoluto (linha laranja tracejada). . . . . . . . . 182

16.1 Interpretação Geométrica da Integral Definida para Integração Numérica . . . . . . . . . . . . 200

16.2 Interpretação Gráfica da Regra do Trapézio (Newton-Cotes de Grau 1). . . . . . . . . . . . . . 201
16.3 Método dos Trapezios Composto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
16.4 Aproximação do integrando pela regra do trapézio. . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
16.5 Aproximação do integrando pela regra de Simpson (ajuste parabólico). . . . . . . . . . . . . . . 206
16.6 Ilustração da Regra de Simpson 1/3 Composta com n = 9 pontos (8 subintervalos), mostrando
os blocos de comprimento 2h. Os coeficientes de ponderação estão indicados sobre os pontos: 1 nos
extremos, 4 nos pontos de índice ímpar e 2 nos pontos de índice par, de acordo com a fórmula da regra
composta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
 Lista de Tabelas

2.1 Principais IDEs para Python e suas características . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3.1 Lista de palavras reservadas em Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.2 Operadores aritméticos do Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

4.1 Conversão de Caracteres para Formatação de Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

6.1 Operadores relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

6.2 Tabela verdade do conectivo de conjunção E (and) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
6.3 Tabela verdade do conectivo de conjunção OU (or) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

10.1 Resumo de estilos e parâmetros do [Link] . . . . . . . . . . . . . . . . . . . . . . . 111

10.2 Comandos LATEX para diversos símbolos matemáticos . . . . . . . . . . . . . . . . . . . . . . . . . . 117
10.3 Comandos LATEX para diversos símbolos matemáticos . . . . . . . . . . . . . . . . . . . . . . . . . . 117
10.4 Símbolos matemáticos e seus comandos em LATEX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
10.5 Principais mapas de cores do Matplotlib (cmap). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

13.1 Estratégia de atualização do intervalo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

14.1 Temp. do café. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

14.2 Tabela de diferenças divididas para um conjunto de dados com seis pontos. . . . . . . . . . . 179
 I
Parte Um: Programação Python

1 Uma Introdução à Programação . . . 17

2 IDE Python para Computação Científica 23
3 Variáveis . . . . . . . . . . . . . . 25
4 Entrada e Saída de Dados . . . . . . 37
5 Matemática Com Python . . . . . . 47
6 Controle de Fluxo . . . . . . . . . . 59
7 Estruturas de Repetição . . . . . . . 67
8 Funções . . . . . . . . . . . . . . 81
9 Matrizes com NumPy . . . . . . . . 89
10 Gráficos com Python . . . . . . . . 105
 1. Uma Introdução à Programação

1.1 O que é um Programa de Computador?

Quando você cria um programa, precisa especificar as instruções que o computador precisará
executar para realizar as operações desejadas. O processo de definir as instruções que o
computador deve executar é conhecido como programação. Os programas de computador,
também conhecidos como software, são compostos por uma sequência de instruções que o
computador executa. Ao criar um programa, é necessário especificar as instruções que o
computador deverá seguir para realizar as operações desejadas. Esse processo de definição
das instruções é chamado de programação. As instruções que o computador executa são,
na verdade, sequências de zeros e uns (0s e 1s), também chamados de dígitos binários,
que representam os sinais eletrônicos internos da máquina. Nos primeiros computadores,
nas décadas de 1940 e 1950, os programadores precisavam entender como o hardware
interpretava diferentes combinações desses dígitos binários, pois os programas eram escritos
diretamente em linguagem de máquina, usando apenas 0s e 1s. Com o aumento da
complexidade dos programas, tornou-se inviável continuar programando diretamente em
código binário. Para resolver esse problema, pesquisadores desenvolveram as linguagens
de programação, que permitem aos programadores expressar instruções de forma mais
clara e acessível aos seres humanos. para um programa em Python. Por exemplo, caso
você crie um programa em Python que realiza um calculo da média das notas de um
aluno, poderia chamar o arquivo que contém as instruções do programa como [Link].
Quando você cria programas, especifica as instruções desejadas usando uma linguagem de
programação. Python é apenas uma entre as muitas linguagens de programação existentes.
Muitos programadores utilizam linguagens como BASIC, Pascal, FORTRAN, C, C++, Java,
Matlab, entre outras. Cada linguagem de programação oferece recursos específicos e possui
seus próprios pontos fortes e limitações. Em todos os casos, o objetivo dessas linguagens
é permitir que possamos definir, de forma precisa, as instruções que queremos que o
computador execute. As instruções de um programa são normalmente armazenadas em um
arquivo de texto puro (ASCII ou UTF-8), cujo nome costuma conter a extensão .py no
caso de programas escritos em Python. Por exemplo, se você criar um programa em Python
para calcular a média das notas de um aluno, poderá nomear o arquivo como [Link]. Ao
desenvolver programas, você utiliza uma linguagem de programação para especificar essas
 18 Capítulo 1. Uma Introdução à Programação

instruções de forma estruturada e compreensível para o computador. Muitos programadores

usam linguagens de programação, tais como BASIC, Pascal, FORTRAN, C, C++, Java,
Matlab e etc. Cada linguagem de programação oferece certos recursos exclusivos, e tem
seus pontos fortes e fracos. Em todos os casos, as linguagens de programação existem
para permitir que definamos as instruções que queremos que o computador execute. Para
programar os primeiros computadores (nos anos 40 e 50), os programadores tinham que
compreender como o computador interpretava diferentes combinações de 0s e 1s pois
os programadores escreviam seus programas usando dígitos binários. À medida que os
programas se tornaram maiores, tornou-se inviável trabalhar em termos de 0s e 1s do
computador. Em vez disso, os pesquisadores criaram as linguagens de programação, que
permitem que as pessoas expressem as instruções do computador de uma forma mais clara
para os humanos. Quando você criar seu arquivo-fonte, certifique-se de atribuir um nome
significativo que descreva com exatidão a função do programa para o arquivo. O Python é
uma linguagem de programação interpretada de script, orientada a objetos, de alto nível e
com semântica dinâmica. A simplicidade do Python reduz a manutenção de um programa.
Python suporta módulos e pacotes, que encoraja a programação modularizada e reuso
de códigos. Este livro é uma introdução à linguagem de programação Python. Python é
uma linguagem interpretada, orientada a objetos, de alto nível e com semântica dinâmica.
Sua sintaxe simples e clara facilita o aprendizado e reduz o esforço de manutenção dos
programas, tornando-a especialmente adequada para iniciantes e para o desenvolvimento
rápido de aplicações. Programas como Dropbox, Reddit e Instagram são escritos em Python.
Além disso, Python consolidou-se como a linguagem mais popular no campo da análise
de dados e em diversas aplicações científicas, sendo amplamente empregada em pesquisas
acadêmicas, desenvolvimento de algoritmos numéricos, aprendizado de máquina, entre
outras áreas. Em capitulos mais adiantes, iremos apresentar pacotes como Math e Numpy.
Python oferece suporte a módulos e pacotes. Esses pacotes contribuem significativamente
para o desenvolvimento de aplicações. Nos capítulos posteriores, serão apresentados alguns
desses pacotes, como o pacote math [15], numpy [3] [12] e matplotlib [4] [9], amplamente
utilizados em aplicações cientificas e de engenharia. O livro também conta com uma
segunda parte dedicada à aplicação do Python na resolução de problemas de Cálculo
Numérico. Nessa etapa, o leitor será guiado por exemplos práticos e exercícios que mostram
como utilizar o Python para implementar algoritmos numéricos, analisar resultados e
compreender conceitos fundamentais dessa área.

1.2 Uma Breve História

Python foi criada em 1990 por Guido Van Rossum no Centro de Matemática Stichting
(CWI) na Holanda como uma sucessora da linguagem ABC [2]. O nome Python vem do
inglês, que significa pitão ou pítion. Pítons são serpentes conhecidas principalmente pelo
seu grande tamanho. No entanto, a verdadeira história por trás do nome da linguagem
Python é um pouco diferente. Na década de 1970, a BBC tinha um programa de TV
popular do qual Guido Van Rossum era um grande fã chamado Fly Circus de Monty
Python [11]. Assim, quando desenvolveu a linguagem, Guido Van Rossum pensou que
precisava de um nome que fosse curto, único e um pouco misterioso, e por algum motivo
que só ele conhecia, decidiu chamar o projeto de Python. O Python cresceu e se tornou
uma linguagem de programação popular, particularmente no meio da Internet.
 1.3 Preparando no Ambiente Windows 19

1.3 Preparando no Ambiente Windows

Antes de você poder programar com Python, você deve

primeiro instalar o software do Python no seu computador
e aprender a como inicializá-lo. O Python não vem insta-
lado por padrão no sistema operacional Windows, portanto,
o download deve ser realizado a partir do site oficial do
Python [16]. Depois, basta executar o instalador e seleci-
onar as opções (i) Install launcher for all users e (ii) Add
Python to PATH. Clique em Next para dar seguimento na
instalação. Por fim, basta clicar em Install e aguardar o
término da instalação. Após o download, execute o ins-
talador e, na primeira tela, marque as opções: (i) Install
launcher for all users e (ii) Add Python to PATH. Em se-
guida, clique em Next para prosseguir e, por fim, clique
em Install. Aguarde até que a instalação seja concluída. Figura 1.1: Guido
Finalizada a instalação, recomenda-se verificar se o Python van Rossum.
foi instalado corretamente. Para isso, execute o Prompt
de Comando e digite o seguinte comando: python -V. Esse comando exibirá a versão do
Python instalada no sistema. Se a versão for impressa, significa que o Python foi instalado
corretamente. Para abrir o prompt de comando, clique em Iniciar e selecione Executar,
digite cmd e clique em OK.

CotoNet@linux:
>> python -V
Python 3.11.3
>>

1.4 Preparando no Ambiente GNU/Linux

Se você é usuário do sistema GNU/Linux, bem... instalar o Python provavelmente foi

uma das primeiras coisas que você fez depois de configurar seu .bashrc com um prompt
colorido e uma mensagem motivacional. Compile o Python direto do código-fonte, assine a
chave GPG dos mantenedores e crie um ambiente virtual antes mesmo de saber o que vai
programar. Aproveite para recompilar o kernel. Não porque você precisa, mas porque pode!
Adicione aquele driver obscuro que melhora a performance do seu modem USRobotics 56K
e crie um disco de boot em um disquete 3 1/2. Após tudo estar funcionando, é fundamental
fazer um printscreen do seu terminal em fullscreen com neofetch aberto com o logo do
Linux em ASCII gigante ao lado de 32 MB de RAM e uptime de 42 dias para postar nas
redes sociais. Afinal, de que adianta ser um hacker de elite se ninguém souber? E para
coroar esse momento de pura estética computacional retrô, abra uma lata de Coca-Cola,
aumente o volume e celebre sua conquista ao ritmo dessa trilha marcante [1].
 20 Capítulo 1. Uma Introdução à Programação

1.5 Salvando seus Programas

Como discutido na Seção 1.1, para criar um programa
em Python, é necessário armazenar as instruções em um
arquivo de texto puro (ASCII ou UTF-8), cujo nome nor-
malmente possui a extensão .py. Esses arquivos contêm
comandos escritos na linguagem Python e são interpretados
sequencialmente, do início ao fim, quando executados pelo
interpretador da linguagem. Tais arquivos são comumente
denominados programas Python, ou seja, conjuntos de ins-
truções previamente definidas para serem processadas pelo
computador. Por fim, é recomendável seguir convenções de
codificação, como a PEP 8, para tornar os programas mais Figura 1.2: Usando o
legíveis e consistentes. Ambiente IDLE.
Como primeiro exemplo, vamos executar o aplicativo IDLE (Ambiente Integrado de
Desenvolvimento e Aprendizagem), um ambiente de desenvolvimento integrado (IDE) para
a linguagem Python. O IDLE oferece um editor de texto compatível com ASCII/UTF-8,
além de ferramentas para escrever, executar e testar seus programas. Clique na Figura 1.2
para obter mais informações sobre o IDLE [10].
Em seguida, digite o código Python e salve-o em um arquivo de texto com o nome
[Link]. Observe a saída do programa no Prompt de Comando do Python. Ao
executar esse programa, o comando print exibirá a seguinte mensagem na janela Prompt
de Comando: Bem-vindo ao curso de Python!. Toda linguagem de programação possui
um conjunto de regras, chamadas regras de sintaxe, que devem ser seguidas ao se utilizar a
linguagem. Ao criar programas em Python, você deve respeitar essas regras de sintaxe.
Exemplos incluem o uso de parênteses após o comando print e o uso correto de aspas
simples. Ao digitar seu programa, tenha atenção para não omitir nenhum desses elementos.
Verifique cuidadosamente a digitação para garantir que o código esteja exatamente conforme
o modelo apresentado.

[Link]
1 print("Bem-vindo ao curso de Python!")

CotoNet@linux:
Bem-vindo ao curso de Python!
>>

1.6 Interpretador Python On-line

Atualmente, existem diversas IDEs e interpretadores Python disponíveis inteiramente
online. Essas plataformas permitem que você escreva, execute e teste seus programas
diretamente no navegador, sem a necessidade de instalar o Python ou configurar qualquer
ambiente de desenvolvimento em sua máquina. A principal vantagem dessas ferramentas
online é a praticidade. Uma dessas ferramentas é o compilador online oferecido pelo site
[Link].
 1.7 Compreendendo os Erros de Sintaxe 21

1.7 Compreendendo os Erros de Sintaxe

Como apresentado na Seção 1.1, cada linguagem de programação tem um conjunto de
regras, chamadas regras de sintaxe, às quais você precisa obedecer. Se você violar uma
regra de sintaxe, seu programa não será compilado com sucesso. Em vez disso, o Python
exibirá mensagens de erro na sua tela que especificam a linha do seu programa que contém
o erro e uma breve descrição do erro. Usando o editor, crie o arquivo [Link],
que contém um erro de sintaxe. No exemplo a seguir, o programa deixou de incluir as
aspas finais na mensagem Bem-vindo ao curso de Python!

[Link]
1 print("Bem-vindo ao curso de Python!)

Quando você executar este programa, o Python exibirá uma mensagem de erro de
sintaxe ao encontrar a linha 1. No caso do Python 3.11 sua tela exibirá as seguintes
mensagens:

CotoNet@linux:
File "<stdin>", line 1
print("Bem-vindo ao curso de Python!)
^
SyntaxError: unterminated string literal (detected at line 1)

Em alguns casos, um erro pode provocar uma série de erros em cascata dentro do
Python. Assim, um único erro pode exibir mais de uma mensagem de erro. No caso do
arquivo [Link], edite o arquivo e acrescente a aspa simples que faltava.

1.8 Comentando Seus programas

Como regra, cada vez que você cria um programa, precisa incluir comentários que expliquem
o processamento que o programa realiza. Basicamente, um comentário é uma mensagem
que o ajuda a ler e compreender o programa. À medida que seus programas aumentarem
de tamanho, eles se tornarão mais difíceis de compreender. O Python oferece um modo
para você colocar comentários dentro do seu arquivo-fonte utilizando o caractere cerquilha
(#).

[Link]
1 # Isto eh um comentario.
2 # Nao sera processado pelo Python.
3 # Pode usar para fazer anotacoes.

Quando o Python encontra o caractere de cerquilha, ele ignora o texto que segue até o
final da linha atual. O programa a seguir, [Link], ilustra o uso de comentários:
 22 Capítulo 1. Uma Introdução à Programação

[Link]
1 #----------------------------------------------------
2 # Curso de Python
3 # UFCG - Campina grande
4 #----------------------------------------------------
5 # Programa: [Link]
6 # Aluno: Rei Arthur
7 # Data de criacao: 25-09-2018
8 # Proposito: Ilustrar o uso de comentarios no Python
9
10 print("Ola, mundo!")

Adquira o hábito de colocar comentários similares no início dos seus programas.

1.9 Usando Comentários para Excluir Comandos do Programa

À medida que seus programas se tornarem mais complexos, você poderá usar comentários
para ajudar a depurar de seus programas. Um segundo modo de eliminar comandos é
transformá-los em comentários. No programa a seguir, todos os comandos print foram
transformados em comentários:
[Link]
1 #----------------------------------------------------
2 # Curso de Python
3 # UFCG - Campina grande
4 #----------------------------------------------------
5 # Programa: [Link]
6 # Aluno: Joao Grilo
7 # Data de criacao: 25-09-2018
8 # Proposito: Ilustrar o uso de comentarios no Python
9 #
10 # print("Ola, mundo!")
 2. IDE Python para Computação Científica

2.1 O que é uma IDE?

O termo IDE, Integrated Development Environment, que em português significa Ambiente de
Desenvolvimento Integrado, refere-se a um programa que reúne um conjunto de ferramentas
essenciais que auxiliam o programador na criação, teste e manutenção de seus projetos.
Uma IDE é projetada para maximizar a produtividade do desenvolvedor e, geralmente,
inclui os seguintes componentes:
• Editor de Código-Fonte: Um editor de texto com recursos específicos para
programação, como realce de sintaxe (uso de cores distintas para diferentes partes do
código), preenchimento automático, indentação automática e outras funcionalidades
que facilitam a escrita do código.
• Compilador ou Interpretador: O software responsável por traduzir o código-fonte
escrito em linguagem humana para uma linguagem compreensível pelo computador,
como código de máquina ou bytecode.
• Depurador (Debugger): Uma ferramenta utilizada para testar e depurar o código,
permitindo a execução passo a passo, a inspeção de variáveis e a identificação precisa
de erros.
Embora o uso de uma IDE não seja obrigatório para desenvolver programas, seu
emprego simplifica significativamente o processo, pois evita que o programador precise
alternar entre diferentes ferramentas para editar, compilar e testar o código.
A linguagem Python conta com diversas IDEs. Entre as mais conhecidas estão o
PyCharm, amplamente utilizado em ambientes profissionais; o Visual Studio Code,
que combina leveza e alta personalização; o Spyder, direcionado para aplicações científicas;
e o Jupyter Notebook, bastante popular em análises de dados e aprendizado de máquina.
Outras opções, como o Thonny e o IDLE, são recomendadas para iniciantes devido à sua
simplicidade e facilidade de uso.
Neste capítulo, serão apresentadas as funcionalidades básicas da IDLE e do Spyder.
A primeira é indicada como uma ferramenta introdutória para quem está começando a
programar em Python, enquanto a segunda é mais apropriada para estudantes, enge-
nheiros e cientistas que buscam um ambiente robusto e voltado à análise numérica e ao
desenvolvimento científico.
 24 Capítulo 2. IDE Python para Computação Científica

IDE Características Principais Público-Alvo Sistema

Operacional
PyCharm [13] Suporte completo a projetos grandes, depu- Profissionais e Windows,
rador avançado, integração com Git e fra- empresas macOS,
meworks web. Linux
Visual Leve, altamente customizável com extensões, Estudantes e Windows,
Studio suporte a múltiplas linguagens e controle de desenvolvedores macOS,
Code [19] versão. Linux
Spyder [17] Focado em computação científica, inclui con- Cientistas e Windows,
sole interativo, integração com NumPy, Mat- pesquisadores macOS,
plotlib e SciPy. Linux
Jupyter Interface interativa baseada em navegador, Analistas de dados Multiplataforma
Notebook [7] ideal para experimentação e visualização de e pesquisadores (web)
dados.
Thonny [18] Interface simples, depurador integrado e ins- Iniciantes e Windows,
talação fácil do Python. estudantes macOS,
Linux
IDLE [5] IDE oficial do Python, leve e já vem instalada Iniciantes Windows,
com a linguagem. macOS,
Linux

Tabela 2.1: Principais IDEs para Python e suas características

2.2 IDE Python para Computação Científica

<texto em revisão>
O Spyder (Scientific Python Development Environment) é uma IDE livre e multipla-
taforma voltada ao ecossistema científico do Python. Ele combina um editor de código
completo (com realce de sintaxe, autocomplete, inspeção de erros e navegação), um con-
sole IPython interativo e um conjunto de painéis projetados para exploração de dados e
depuração, numa experiência semelhante ao fluxo de trabalho do MATLAB.
O Spyder (Scientific Python Development Environment) é uma IDE pensada para o fluxo
de trabalho científico: combina um editor com realce, linting e auto-complete, consoles
IPython interativos, um Explorador de Variáveis que inspeciona/edita matrizes do NumPy e
DataFrames do pandas, ajuda contextual (Ctrl+I), gráficos do matplotlib com histórico,
além de depurador passo a passo e profiler. Para computação científica, isso se traduz em
ciclos curtos editar → executar → inspecionar → ajustar, validação rápida de resultados,
menor atrito ao usar NumPy/SciPy/pandas, diagnóstico ágil de erros de indexação ou
convergência e otimização guiada por medidas; somam-se projetos e ambientes isolados
(conda/venv) que reforçam a reprodutibilidade. Na prática, o Spyder acelera protótipos
de métodos numéricos, facilita a análise exploratória e ajuda a transformar experimentos
em código limpo e confiável.
Prefira o Spyder quando o trabalho pedir prototipagem científica rápida com forte
interação com arrays do NumPy e DataFrames do pandas, pois o Explorador de Variáveis, os
consoles IPython e o histórico de gráficos permitem validar hipóteses e ajustar parâmetros
em ciclos curtos. Em ensino e demonstrações de Métodos Numéricos, a combinação de
depurador passo a passo, ajuda contextual e visualização imediata facilita expor algoritmos
e diagnosticar erros. Já na migração de cadernos exploratórios para scripts/modularização
com testes, os recursos de projetos, integração com ambientes (conda/venv) e o profiler
favorecem reprodutibilidade, organização e otimização do desempenho—acelerando a
passagem do protótipo para código limpo e confiável.
 3. Variáveis

3.1 Apresentando as Variáveis

Para que um programa seja realmente útil, ele precisa ser capaz de armazenar e manipular
informações. Como você já sabe, sempre que executa um programa, o sistema operacional
(como o Windows) carrega as instruções do programa na memória do computador. Durante
a execução, o programa armazena dados temporariamente em posições de memória.
Por exemplo, imagine um programa que imprime documentos. Sempre que o programa
é iniciado, ele pode solicitar ao usuário o nome do arquivo e o número de cópias a serem
impressas. Quando essas informações são fornecidas, o programa precisa armazená-las em
locais específicos da memória do computador. Para organizar esses dados, cada posição de
memória tem um endereço único — como 0, 1, 2, 3 e assim por diante. No entanto, como
existem bilhões de endereços possíveis, manter o controle de posições de armazenamento
individuais seria impraticável.
Para tornar esse processo mais simples e eficiente, os programas utilizam variáveis.
Variáveis são nomes simbólicos que o programa associa a determinadas posições na memória,
permitindo armazenar e acessar informações de maneira mais intuitiva. Como o próprio
nome sugere, o valor de uma variável pode mudar durante a execução do programa.
Cada variável também possui um tipo de dado, que informa ao computador quanto
espaço de memória será necessário e quais operações podem ser realizadas com aquele
conteúdo. Retomando o exemplo do programa de impressão, ele pode utilizar uma
variável chamada nomearq para armazenar o nome do arquivo e outra chamada conta para
armazenar o número de cópias a serem impressas. Dentro do código, você acessa esses
valores utilizando os nomes das variáveis, por isso é importante dar nomes representativos
a cada variável.

3.2 Como Declarar uma Variável

Para declarar uma variável em Python, você deve atribuir um valor a ela utilizando o
caractere de igual =, conhecido como o operador de atribuição. O programa a seguir,
[Link], declara três variáveis: nota1, nota2 e nota3, atribuindo a cada uma delas um
valor numérico. Em seguida, é criada uma quarta variável chamada media, que recebe
 26 Capítulo 3. Variáveis

como valor o resultado da expressão (nota1 + nota2 + nota3) / 3, correspondente à

média aritmética das três notas.

[Link]
1 nota1 = 5.5
2 nota2 = 8.3
3 nota3 = 9.7
4 media = (nota1+nota2+nota3)/3

3.3 Melhorando a Legibilidade do Seu Programa

Na Seção 1.8, você aprendeu como utilizar comentários em seus programas para torná-
los mais legíveis. Sempre que criar um programa, tenha em mente que você - ou outro
programador - poderá precisar modificá-lo futuramente. Por isso, é fundamental que seu
código seja escrito de forma clara e compreensível.
O exemplo a seguir, [Link], apresenta uma versão do programa [Link] com
pouca legibilidade, ilustrando a importância de escrever código bem estruturado e comen-
tado.

[Link]
1 ASgg_g = 5.5
2
3
4 NP2_dia = 8.3
5
6
7 as2323D = 9.7
8
9
10 MAASE = ( ASgg_g+ NP2_dia+as2323D)/3
11
12

Embora este programa esteja correto e exiba a mensagem desejada, sua leitura é
bastante difícil -para dizer o mínimo. Um bom programa não deve apenas funcionar, mas
também ser fácil de entender e manter. A chave para criar códigos legíveis está em utilizar
nomes de variáveis intuitivos, adicionar comentários que expliquem o funcionamento do
programa e empregar linhas em branco para organizar visualmente o código. Em seções
futuras, você aprenderá também sobre o papel fundamental da indentação na estruturação
de programas bem organizados e fáceis de ler.

3.4 Usando Nomes Representativos para as Variáveis

Ao declarar variáveis em programas, é importante escolher nomes representativos, que
descrevam claramente o propósito de cada variável. É permitido o uso de letras maiúsculas
e minúsculas nos nomes, mas deve-se ter atenção ao fato de que o Python diferencia letras
maiúsculas de minúsculas - ou seja, trata-se de uma linguagem case-sensitive. Por
exemplo, os nomes nomeAluno e Nomealuno são considerados distintos.
Para iniciantes, recomenda-se utilizar apenas letras minúsculas nos nomes das variáveis, o
que ajuda a reduzir erros comuns relacionados à sensibilidade entre maiúsculas e minúsculas.
 3.5 Compreendendo as Palavras Reservadas em Python 27

Cada variável declarada deve possuir um nome único dentro do programa. Em Python,
os nomes válidos são compostos por uma sequência de letras e/ou números, iniciando
sempre com uma letra. Apenas letras comuns (sem acentuação) são permitidas. Não é
permitido ou recomendado o uso de acentos, cedilha, espaços ou caracteres especiais como
$, #, @, entre outros.
Regras para nomes de variáveis:
• O nome deve iniciar, obrigatoriamente, com uma letra (a–z ou A–Z), podendo conter
letras e números nos demais caracteres.
• Python é uma linguagem case-sensitive: diferencia letras maiúsculas de minúsculas.
• Devem ser utilizados nomes significativos e coerentes com o contexto do programa.
• Nomes de variáveis não podem coincidir com comandos ou palavras reservadas da
linguagem (por exemplo: if, while, def, entre outros).
Embora seja tecnicamente possível iniciar o nome de uma variável com _, essa prática
não é recomendada, salvo em situações específicas, como convenções internas ou casos de
uso especial.

3.5 Compreendendo as Palavras Reservadas em Python

A linguagem Python define um conjunto de palavras reservadas (também chamadas
de palavras-chave) que possuem significado especial e são interpretadas diretamente pelo
interpretador da linguagem. Essas palavras fazem parte da estrutura fundamental da sintaxe
do Python, sendo utilizadas para definir comandos, estruturas de controle, declarações e
outras construções essenciais da linguagem.
Por esse motivo, essas palavras não podem ser utilizadas como nomes de variáveis,
funções, classes ou quaisquer outros identificadores criados pelo programador, pois isso
causaria erro de sintaxe durante a execução do código.
O número e o nome das palavras reservadas podem variar levemente entre versões
da linguagem, pois novas palavras podem ser introduzidas com o surgimento de novos
recursos. A versão atual do Python (3.12), por exemplo, reconhece 36 palavras reservadas.
A Tabela 3.1 apresenta a lista completa das palavras reservadas atualmente reconhecidas
pela linguagem Python.

and as assert async

await break class continue
def del elif else
except False finally for
from global if import
in is lambda None
nonlocal not or pass
raise return True try
while with yield

Tabela 3.1: Lista de palavras reservadas em Python

 28 Capítulo 3. Variáveis

3.6 Tipos de Variáveis

Python é uma linguagem de tipagem dinâmica, o que significa que o programador não
precisa declarar explicitamente o tipo de uma variável no momento em que ela é criada.
Em vez disso, o interpretador determina automaticamente o tipo da variável com base no
valor atribuído a ela.
Essa característica torna a linguagem mais flexível e acessível, especialmente para
iniciantes. Além disso, o tipo de uma variável pode mudar ao longo da execução do
programa, conforme novos valores lhe forem atribuídos.
O tipo de uma variável é fundamental, pois define a natureza dos dados que ela
armazena (como números, textos, listas, entre outros) e determina as operações que podem
ser realizadas sobre esses dados. A seguir, apresentamos os principais tipos de dados
utilizados em Python:

• int - Númerico inteiros.

(exemplo: -3, 4, 5)
• float - Ponto Flutuante ou Decimal.
(exemplo: -3.3, 1.5)
• str - Cadeira de caracteres.
(exemplo: "Ola ano 2023!")
• bool - Valores booleanos.
(exemplo: True, False)
• complex - Número Complexo.
• list - Lista.
• tuple - Tupla
No exemplo anterior (programa [Link]), armazenamos três numéros float nas
variáveis nota1, nota2 e nota3, além da média final na variável media.

3.6.1 Compreendendo as Variáveis do Tipo INT

Em Python, o tipo int é utilizado para representar valores inteiros, ou seja, números
sem parte decimal - tanto positivos quanto negativos. Diferentemente de muitas outras
linguagens de programação, que limitam o tamanho de inteiros com base na arquitetura
(como 32 ou 64 bits), o Python 3 permite que inteiros cresçam dinamicamente conforme
necessário. O único limite prático para o tamanho de um inteiro é a quantidade de memória
disponível no sistema.
Vale destacar uma diferença importante entre versões da linguagem: No Python 3.x,
existe apenas um tipo int, capaz de representar tanto inteiros pequenos quanto valores
muito grandes, com precisão ilimitada. Já no Python 2.7, havia dois tipos distintos para
inteiros: o tipo int, normalmente implementado com 32 bits (com limites finitos), e o tipo
long, usado para representar inteiros maiores, com tamanho variável - equivalente ao int
do Python 3.
 3.6 Tipos de Variáveis 29

[Link]
1 idade = 19
2 valor = -100
3
4 x = 1000**100
5 print(x)
6
7 y = 10000**10000
8 print(y)

O trecho de código acima, [Link], apresenta como o Python lida com operações
envolvendo inteiros de tamanhos extremamente grandes. Na linha 4, o programa calcula o
valor de 1000100 e armazena o resultado na variável x. Esse valor, embora grande, ainda é
possível de ser representado e impresso corretamente. Em seguida, na linha 7, o programa
tenta calcular o valor de 1000010000 , armazenando o resultado na variável y. No entanto,
esse valor é tão grande que o Python pode não conseguir alocar memória suficiente ou
pode atingir limites internos de tempo ou recursos computacionais.

CotoNet@linux:

100000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
ValueError: Exceeds the limit (4300 digits) for integer
string conversion; use sys.set_int_max_str_digits() to
increase the limit

3.6.2 Compreendendo as Variáveis do Tipo FLOAT

O tipo float em Python é utilizado para representar valores numéricos com parte
fracionária, isto é, números reais, positivos ou negativos, que contêm casas decimais.
Esses valores são armazenados em ponto flutuante, de acordo com a especificação IEEE
754 de precisão dupla (64 bits), permitindo uma ampla faixa de representação numérica,
com aproximadamente 15 dígitos decimais de precisão.

[Link]
1 # exemplo de variavel do tipo float
2
3 peso = 75.54 # peso em kg
4 altura = 1.75 # altura em metros
5 imc = peso / (altura ** 2)
6

No exemplo acima, as variáveis peso e altura armazenam valores do tipo float,

representando respectivamente o peso corporal (em kg) e a altura de uma pessoa (em
metros). Esses valores podem ser utilizados em expressões matemáticas, como no cálculo
 30 Capítulo 3. Variáveis

do índice de massa corporal (IMC), que envolve divisão de números em ponto flutuante. Ao
executar esse programa, o interpretador Python realizará as operações de ponto flutuante
e exibirá o resultado com a devida precisão.

3.6.3 Compreendendo os Problemas e Limitações do FLOAT

Ao utilizar números de ponto flutuante (float), é fundamental estar atento a questões de
precisão numérica e erros de arredondamento. Devido à forma como esses números
são representados internamente pelo computador, operações com valores float podem
produzir resultados ligeiramente imprecisos ou inesperados.
Todo número decimal, seja um valor inteiro (int) ou de ponto flutuante (float), precisa
ser convertido para a base binária para ser representado na memória. Enquanto os valores
inteiros costumam ter uma conversão exata, muitos números reais como 0.1 não podem ser
representados precisamente em binário. A representação binária do número decimal 0.1
será:

0.110 = 0.0001100110011001100 . . .2 (3.1)

Sendo 0.0001100110011001100 com uma dízima periódica 0011 que se repete infini-
tamente. Portanto, por conta da dízima periódica, o valor não pode ser representado
precisamente (não existe memória infinita para representar uma dízima que se repete
infinitamente). Assim, quando convertemos 0.00011001100110011012 novamente para a
base 10, temos:

0.00011001100110011012 ≈ 0.1000000000000000210 (3.2)

Ou seja, um erro da ordem de 0.00000000000000002 (ou ainda 2 × 10−17 ) foi introduzido.

Esse fenômeno é inerente à aritmética de ponto flutuante e pode se acumular em operações
sucessivas. Por isso, deve-se evitar comparar diretamente dois números float quanto à
igualdade, pois o resultado pode ser logicamente incorreto, mesmo que os valores aparentem
ser iguais. Para ilustrar, veja o seguinte programa:
[Link]
1 x = 1.2 - 1.0
2 print(x)

Ao executá-lo, o valor impresso na tela será:

CotoNet@linux:
0.19999999999999996

3.6.4 Compreendendo as Variáveis do tipo STR

O Python utiliza o tipo str para armazenar valores de texto (strings), como o nome de
uma pessoa, por exemplo. Assim, o tipo str representa uma sequência de caracteres que
forma uma string. O Python permite criar strings utilizando um par de aspas simples,
aspas duplas ou aspas triplas (estas últimas úteis para textos com múltiplas linhas). O
exemplo do programa [Link] ilustra a criação e a exibição de variáveis desse tipo.
Uma característica importante das strings em Python é que elas são imutáveis. Isso
significa que, uma vez criada, uma string não pode ser modificada. Qualquer operação que
pareça modificar uma string, na verdade, cria uma nova string.
 3.6 Tipos de Variáveis 31

[Link]
1 nome_1 = "Lucas Ribeiro"
2 nome_2 = 'Princesa Leia'
3 nome_1 = "Lucas Ribeiro de Almeida"
4 mensagem = """Ola,
5 Mundo!?"""
6
7 print(nome_1)
8 print(nome_2)
9 print(mensagem)

CotoNet@linux:
Lucas Ribeiro de Almeida
Princesa Leia
Ola,
Mundo!

3.6.5 Compreendendo as Variáveis do tipo BOOL

O Python utiliza o tipo bool para representar dados booleanos, definidos pelas palavras-
chave True (Verdadeiro) e False (Falso). Esse tipo é geralmente usado para expressar
o resultado de avaliações da lógica booleana [20], como comparações e condições em
estruturas de decisão. Os fundamentos da lógica booleana serão abordados com mais
detalhes no Capítulo 6. O exemplo a seguir, presente no programa [Link],
mostra a criação e exibição de variáveis booleanas.

[Link]
1 doadorSangue = True
2 doadorOrgaos = False

3.6.6 Compreendendo as Variáveis do tipo COMPLEX

O Python utiliza o tipo complex para representar números complexos, que são normalmente
usados em cálculos geométricos, científicos e de engenharia. Uma variável desse tipo contém
duas partes: a parte real e a parte imaginária. O Python permite criar números complexos
diretamente, usando a letra j para indicar a parte imaginária, ou por meio da função
complex(). O exemplo a seguir, no programa [Link], demonstra a criação
e a exibição de variáveis desse tipo.

[Link]
1 # Forma direta,
2 a = 5+2j
3 b = 20+6j
4
5 # Usando a funcao complex()
6 z3 = complex(2, 5)
7
8 print(z1)
9 print(z2)
10 print(z3)
 32 Capítulo 3. Variáveis

3.6.7 Compreendendo as Variáveis do tipo LIST

O Python utiliza o tipo list para representar uma coleção de elementos ordenados e
mutáveis. Isso significa que os elementos da lista mantêm uma ordem definida e podem ser
alterados após a criação é possível modificar, inserir, remover ou reordenar itens conforme
necessário.

Uma lista pode armazenar múltiplos valores em uma única variável, inclusive valores de
tipos diferentes. Por exemplo: números inteiros (int), números decimais (float), textos
(str), valores lógicos (bool), e até mesmo outras listas, permitindo a criação de listas
aninhadas. As listas são delimitadas por colchetes [], e seus elementos são separados por
vírgulas. Veja um exemplo:

[Link]
1 alunos = ["Amanda", "Ana", "Bruno", "Carlos"]
2 notas = [10, 8.5, 3.8, 8.0]
3 aprovado = [True, True, False, True ]
4
5 print(alunos)
6 print(notas)
7 print(aprovado)

Além da criação, o Python oferece diversas formas de manipular listas, como a mo-
dificação de elementos, inserção de novos itens, remoção de valores e reorganização do
conteúdo. Essas operações tornam as listas uma estrutura de dados bastante poderosa
e flexível. Mais adiante, abordaremos com mais detalhes a manipulação de listas em
estruturas bidimensionais, conhecidas como matrizes.

• Acessar elementos: usando índices (nomes[0] retorna "Ana").

• Modificar elementos: notas[1] = 7.5 altera a segunda nota.
• Adicionar elementos: com append() ou insert().
• Remover elementos: com remove() ou pop().

3.6.8 Compreendendo as Variáveis do tipo TUPLE

O Python utiliza o tipo tuple (tupla) para representar estruturas de dados capazes de
armazenar múltiplos valores em uma única variável, de forma semelhante às listas. A
principal diferença é que, ao contrário das listas, as tuplas são imutáveis: uma vez
criadas, seus elementos não podem ser modificados.

Podemos criar uma tupla utilizando parênteses (). Embora o uso dos parênteses seja
a forma mais comum, também é possível definir uma tupla apenas com vírgulas, sem os
parênteses. É importante destacar que, no caso de uma tupla com apenas um elemento,
a vírgula é obrigatória para que o Python a reconheça como tupla, e não como um valor
isolado. Veja o exemplo no programa [Link].
3.6 Tipos de Variáveis 33

[Link]
1 tupla1 = ("uva", "banana", "laranja")
2 tupla2 = "uva", "banana", "laranja"
3 tupla3 = (5,)
4 nao_tupla = (5)
5 print("Tipo de %s: %s" % (tupla1, type(tupla1)))
6 print("Tipo de %s: %s" % (tupla2, type(tupla2)))
7 print("Tipo de %s: %s" % (tupla3, type(tupla3)))
8 print("Tipo de %s: %s" % (nao_tupla, type(nao_tupla)))

CotoNet@linux:
Tipo de ('uva', 'banana', 'laranja'): <class 'tuple'>
Tipo de ('uva', 'banana', 'laranja'): <class 'tuple'>
Tipo de (5,): <class 'tuple'>
Tipo de 5: <class 'int'>

[Link]
1 # Lista (mutavel)
2 lista = [10, 20, 30]
3 lista[1] = 99
4 print("Lista modificada:", lista)
5
6 # Tupla (imutavel)
7 tupla = (10, 20, 30)
8 # Tentativa de modificacao (vai gerar erro!)
9 tupla[1] = 99 # TypeError

CotoNet@linux:
Lista modificada: [10, 99, 30]
----> 9 tupla[1] = 99 # TypeError
TypeError: 'tuple' object does not support item assignment

O uso de tuplas é bastante comum em Python para retornar múltiplos valores de uma
função. Como as tuplas são imutáveis e organizadas, elas permitem agrupar os dados de
forma prática e segura. Também é possível desempacotar o resultado da tupla diretamente
em duas variáveis. O programa [Link] testa esses conceitos.

[Link]
1 # O resultado da tupla diretamente em uma variavel:
2 resultado = divmod(10, 3)
3 print(resultado)
4 print("Quociente:", resultado[0])
5 print("Resto:", resultado[1])
6 # O resultado da tupla diretamente em duas variaveis:
7 q, r = divmod(17, 5)
8 print("Quociente:", q)
9 print("Resto:", r)
 34 Capítulo 3. Variáveis

3.7 Como Identificar o Tipo de Variável

Na Seção 3.6, foi apresentado que o tipo de uma variável está relacionado à natureza
dos dados que ela armazena. Em Python, os tipos mais comuns são: (i) int, (ii) float,
(iii) str, (iv) bool, (v) complex e (vi) list. Esses tipos permitem representar números
inteiros, números reais, textos, valores lógicos, números complexos e coleções de dados,
respectivamente. Embora existam outros tipos mais específicos ou menos utilizados, esses
são os mais frequentes no desenvolvimento de programas, especialmente em contextos
introdutórios e de uso geral.
Em determinadas situações, especialmente durante a depuração [21] de programas (a
identificação e correção de erros no código), é importante conhecer qual é o tipo de uma
variável. Para isso, o Python fornece a função type(), que retorna o tipo do valor passado
como argumento. O programa a seguir, [Link], exemplifica o uso da função
type() para identificar os tipos de diversas variáveis:

[Link]
1 # Declaracao de variaveis:
2 idade = 23 # int
3 altura = 1.75 # float
4 nome = "Lucas Ribeiro" # str
5 doador_sangue = True # bool
6 numero_complexo = complex(2, 5) # complex
7 notas = [8.5, 7.8, 9.0] # list
8 resultado = divmod(10, 3) # tupla
9 # Imprime o tipo de cada variavel
10 Tipo de idade___________: <class 'int'>
11 Tipo de altura__________: <class 'float'>
12 Tipo de nome____________: <class 'str'>
13 Tipo de doador_sangue___: <class 'bool'>
14 Tipo de numero_complexo_: <class 'complex'>
15 Tipo de notas___________: <class 'list'>
16 Tipo de resultado_______: <class 'tuple'>

CotoNet@linux:
Tipo de idade___________: <class 'int'>
Tipo de altura__________: <class 'float'>
Tipo de nome____________: <class 'str'>
Tipo de doador_sangue___: <class 'bool'>
Tipo de numero_complexo_: <class 'complex'>
Tipo de notas___________: <class 'list'>
Tipo de resultado_______: <class 'tuple'>

3.8 Conversão entre Tipos de Variáveis

Durante o desenvolvimento de programas, é comum surgirem situações em que seja
necessário converter valores de um tipo para outro, com o objetivo de manipulá-los de
forma adequada ao contexto. Por exemplo, pode ser necessário concatenar um número
inteiro (int) com uma cadeia de caracteres (str) para formar uma mensagem, ou ainda
representar um número inteiro como ponto flutuante (float) para realizar cálculos mais
precisos. Essas transformações entre tipos são chamadas de conversões de tipo, e o
 3.9 Operadores Aritméticos 35

Python oferece funções nativas para realizá-las de forma simples. As principais funções
para conversão de tipos são:

• float() - Converte um valor para ponto flutuante.

• int() - Converte um valor para inteiro, descartando a parte decimal se houver.
• str() - Converte um valor para uma cadeia de caracteres (string).

O programa a seguir, [Link], apresenta exemplos de conversões entre

tipos de variáveis:

[Link]
1 ex_int = 5
2 ex_float = 8.9
3 ex_str = "Lucas"
4
5 ex_int2 = float(ex_int) # converte int para float
6 ex_float2 = int(ex_float) # converte float para int
7 ex_float3 = str(ex_float) # converte float para string
8
9 print(ex_int2, type(ex_int2))
10 print(ex_float2, type(ex_float2))
11 print(ex_float3, type(ex_float3))

3.9 Operadores Aritméticos

A maioria dos operadores em Python se comporta de maneira semelhante aos operadores

matemáticos tradicionais, o que facilita a leitura e a escrita de expressões numéricas. Por
exemplo, na expressão a + b, o símbolo + representa o operador aritmético de adição,
enquanto a e b são os operandos, valores sobre os quais a operação será realizada.

Em Python, no contexto dos operadores matemáticos, os operandos geralmente são

valores dos tipos int (inteiros) ou float (números de ponto flutuante), mas também podem
ser variáveis que armazenam esses tipos. Os operadores aritméticos permitem realizar
operações básicas como adição, subtração, multiplicação e divisão, além de outras variações
importantes, como exponenciação e divisão inteira.

Embora os operadores aritméticos sejam tradicionalmente utilizados em operações

matemáticas, em Python eles também podem ser aplicados no contexto de variáveis do
tipo string. Por exemplo, o operador +, quando usado com strings, serve para concatenar
duas cadeias de caracteres, enquanto o operador * pode ser utilizado para repetir uma
determinada string um número específico de vezes. Vale destacar que os operadores de
subtração (-), divisão (/) e exponenciação (**) não são válidos para strings, e seu uso
resultará em erro.

A Tabela 3.2 apresenta um resumo dos principais operadores aritméticos disponíveis

em Python, incluindo seus símbolos, nomes e respectivos comportamentos. Já o programa
[Link] traz um exemplo prático que demonstra a criação de variáveis e a
aplicação desses operadores em expressões numéricas e de strings.
36 Capítulo 3. Variáveis

[Link]
1 # Tipo: Numerico (int e float)
2 a = 5
3 b = 3
4 c = a + b # soma de dois numeros
5 d = a - b # subtracao de dois numeros
6 e = a * b # multiplicacao de dois numeros
7 f = a / b # divisao de dois numeros
8 g = a % b # modulo de dois numeros
9 h = a ** b # exponenciacao de dois numeros
10 print(c)
11 print(d)
12 print(e)
13 print(f)
14 print(g)
15 print(h)
16 # Tipo: String (str)
17 msg = "Oi"
18 nome = "Lucas"
19 print(msg + " " + nome)
20 print(msg * 3)

CotoNet@linux:
8
2
15
1.6666666666666667
2
125
Oi Lucas
OiOiOi

Símbolo Operador Conceito Exemplo

+ Adição Realiza a soma entre operandos 10 + 7
- Subtração Realiza a subtração entre operandos 10 - 7
* Multiplicação Realiza a multiplicação entre operandos 3 * 4
/ Divisão Realiza a divisão entre operandos 10 / 3
// Divisão Realiza a divisão inteira entre operandos 10 // 3
% Módulo Retorna o resto da divisão entre operandos 4 % 2
** Exponenciação Retorna um número elevado a potência 4 ** 2

Tabela 3.2: Operadores aritméticos do Python.

 4. Entrada e Saída de Dados

4.1 Introdução a Função print()

Diversas dicas apresentadas neste livro, incluindo exemplos já utilizados nos Capítulos 1 e 3,
fazem uso da função print() para exibir mensagens no Prompt de Comando. Sempre
que o seu programa utiliza a função print(), as informações fornecidas entre parênteses
(chamadas de parâmetros ou argumentos da função) será exibido na tela.
A maneira mais simples de usar a função print() é passando uma mensagem entre
aspas simples (') ou aspas duplas ("). Ambas são equivalentes em Python, e a escolha
entre uma ou outra é apenas uma questão de estilo ou conveniência. O exemplo a seguir
utiliza a função print() para exibir a mensagem Bem-vindo ao curso de Python! no
terminal:

[Link]
1 print("Bem-vindo ao curso de Python!")

CotoNet@linux:
Bem-vindo ao curso de Python!

4.2 Como Exibir na Tela um Texto Incluindo Aspas

Para exibir o caractere de aspas (simples ou duplas) dentro da própria mensagem, utiliza-se
o recurso conhecido como escape. O escape permite representar caracteres especiais dentro
de uma string. Para isso, basta adicionar o caractere contrabarra (ou barra invertida) (\)
antes do caractere que se deseja exibir literalmente. No exemplo a seguir, o caractere de
escape é usado para imprimir corretamente aspas duplas e apóstrofo:

[Link]
1 print("\"Bem-vindo ao McDonald\'s!\"")
 38 Capítulo 4. Entrada e Saída de Dados

CotoNet@linux:
"Bem-vindo ao McDonald's!"

4.3 Quebra de Linha Usando a Função print()

Caso não seja fornecido nenhum parâmetro, a função print() irá apenas exibir uma quebra
de linha na tela. Caso o objetivo realmente seja um quebra de linha, a função print()
poderia ser chamada várias vezes em sequência. O programa [Link] demonstra
um exemplo de quebra de linha usando a função print().

[Link]
1 print("Bem-vindo ao curso de Python!")
2 print()
3 print("Voce pode usar aspas simples")
4 print()
5 print("ou pode usar aspas duplas")

CotoNet@linux:
Bem-vindo ao curso de Python!

Voce pode usar aspas simples

ou pode usar aspas duplas

Dessa forma até teríamos o resultado pretendido, mas outra forma simples e correta,
com apenas uma chamada de função seria utilizando uma quebra de linha usando o scape
\n.

[Link]
1 print('Bem-vindo ao \n curso de Python!')

CotoNet@linux:
Bem-vindo ao
curso de Python!

4.4 Como Exibir na Tela o Conteúdo de uma Variável

A função print() também pode ser utilizada para exibir o conteúdo previamente armaze-
nado em variáveis, independentemente do seu tipo, como int, float ou str. O exemplo a
seguir demonstra a impressão de três variáveis: uma string com o nome de uma pessoa,
um número inteiro representando a idade e um número real indicando a altura:
 4.5 Usando a Função print() para Imprimir a Saída de Outra Função 39

[Link]
1 nome = "Lucas Ribeiro"
2 idade = 21
3 altura = 1.75
4 print(nome)
5 print(idade)
6 print(altura)

CotoNet@linux:
Lucas Ribeiro
21
1.75

4.5 Usando a Função print() para Imprimir a Saída de Outra Função

A função print() também pode ser utilizada para exibir na tela a saída (ou retorno) de
outras funções. Por exemplo, na Seção 3.7 vimos que a função type() retorna o tipo de
qualquer variável fornecida como parâmetro. Podemos combinar essas duas funções para
exibir essa informação diretamente no terminal. Veja o exemplo:

[Link]
1 idade = 23
2 altura = 1.75
3 nome = "Lucas Ribeiro"
4 doadorSangue = True
5
6 print(type(idade))
7 print(type(altura))
8 print(type(nome))
9 print(type(doadorSangue))

CotoNet@linux:
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

4.6 Usando a Função print() com Múltiplos Argumentos

Também é possível passar múltiplos argumentos para a função print(), separados por
vírgulas. Nesse caso, cada argumento será concatenado automaticamente com os demais,
resultando em uma única mensagem exibida na tela. Por padrão, o Python insere um
espaço entre os elementos. O exemplo a seguir mostra como combinar variáveis e strings
literais em uma mesma chamada da função print():

[Link]
1 nome = "Lucas Ribeiro"
2 curso = "Engenharia"
3 print(nome, "cursa", curso)
 40 Capítulo 4. Entrada e Saída de Dados

CotoNet@linux:
Lucas Ribeiro cursa Engenharia

4.7 Como Usar a Função print() sem Quebra de Linha

Por padrão, o Python acrescenta uma quebra de linha ao final do comando print():
Por padrão, a função print() em Python acrescenta uma quebra de linha (\n) ao final
de cada chamada. Isso significa que, ao usar múltiplos comandos print() em sequência,
cada mensagem será impressa em uma nova linha. Veja o exemplo abaixo:

[Link]
1 print("Ola")
2 print("Mundo!")

CotoNet@linux:
Ola
Mundo!

Se desejarmos imprimir múltiplos valores na mesma linha, podemos usar o parâmetro

end=" " para modificar o caractere final. Por exemplo, para evitar a quebra de linha e
inserir um espaço entre as palavras:

[Link]
1 print("Ola", end = " ")
2 print("Mundo!")

CotoNet@linux:
Ola Mundo!

4.8 Usando a Função print() com Marcador de Posição

Quando você quiser que a função print() exiba o valor de uma variável dentro de um
texto, será necessário fornecer informações sobre como esse valor deve ser formatado. Para
isso, podemos utilizar os chamados marcadores de posição (placeholders), que indicam à
função print() como os valores das variáveis devem ser inseridos na string.
O uso de marcadores de posição é uma das formas mais antigas de formatação de texto
em Python. Apesar de existirem abordagens mais modernas (como o uso de f-strings
ou o método format()), essa técnica ainda é bastante comum, especialmente em códigos
legados ou para programadores que vêm de outras linguagens, como C, Java e C++. O
exemplo a seguir ilustra uma aplicação simples com marcador de posição:

[Link]
1 nome = "Lucas"
2 print("Ola %s, tudo bem?" % nome )

Nesse caso, o operador % é conhecido como operador de formatação. O lado esquerdo

da expressão contém a string de formatação, com um marcador de posição (%s), e o lado
direito fornece o valor que será inserido nesse marcador.
 4.9 Exibindo Valores do Tipo int Usando print() 41

Importante: o número de valores fornecidos à direita do operador % deve corresponder

ao número de marcadores de posição presentes na string. Os valores são aplicados na
ordem em que aparecem, da esquerda para a direita.
Como você verá nos exemplos a seguir, é possível utilizar múltiplos marcadores de
posição na mesma string. Quando isso ocorrer, a ordem dos valores fornecidos deve respeitar
a ordem dos marcadores no texto. As próximas seções discutirão com mais detalhes os
principais especificadores de formato disponíveis com essa técnica.

Esquema: print()

frase que será impressa na tela

variáveis na ordem
que aparecer na frase

print(’Olá %s, tudo bem? Você tem %d anos!’ % (nome, idade))

%s : marcador de posição para %d : marcador de posição para

variável do po string (str) variável do po inteiro (int)

[Link]
1 nome = "Lucas"
2 idade = 21
3 print("Ola %s, tudo bem? Voce tem %d anos!" % (nome, idade))

CotoNet@linux:
Ola Lucas, tudo bem? Voce tem 21 anos!

A tabela a seguir apresenta os marcadores de posição mais comuns utilizados na

formatação de strings com o operador %:

d, i Inteiro (int).
f Ponto Flutuante (float).
e Ponto Flutuante (float) em notação científica. Letra e para
a letra e para indicar o expoente.
%.2f Ponto Flutuante (float) com 2 casas decimais.
s String (str), ou qualquer tipo do Python que possa ser
convertido para string usando a função.
% Inserir um caractere.

Tabela 4.1: Conversão de Caracteres para Formatação de Strings

4.9 Exibindo Valores do Tipo int Usando print()

Para exibir valores do tipo int, use o especificador de formato %d O programa a seguir,
[Link], usa o especificador de formato %d para exibir valores e variáveis do tipo int:
 42 Capítulo 4. Entrada e Saída de Dados

[Link]
1 idade = 25
2 print("A idade do aluno eh %d anos \n" % (idade))

Quando você executar o programa [Link], sua Janela de Comando exibirá a

seguinta saída:

CotoNet@linux:
A idade do aluno eh 25 anos

4.10 Exibindo uma string Usando print()

Uma string é uma sequência de caracteres. Uma das operações mais comuns que seus
programas executarão é a saída de string de caracteres. Como você aprendeu, a função
print suporta os especificadores de formato que oferecem informações sobre seus tipos
de parâmetro. Para exibir uma string de caracteres usando print, você deverá usar o
especificador de formato %s. O programa a seguir, [Link], usa o especificador de
formato %s para exibir uma string de caracteres:

[Link]
1 nome = "Ana"
2 print("Ola %s, tudo bem? Quantos anos voce tem? \n" % (nome))

Quando você executar o programa [Link], sua Janela de Prompt de Comando

exibirá a seguinta saída:

CotoNet@linux:
Ola Ana, tudo bem? Quantos anos voce tem?

4.11 Exibindo Valores do Tipo float Usando print()

Para exibir valores do tipo float com o comando print, você deverá usar o especificador
de formato %f. O programa a seguir, [Link], usa o especificador de formato %f para
exibir valores em ponto flutuante:

[Link]
1 preco = 45.95
2 imposto = 0.06
3 imposto_venda = preco * imposto
4 print("O imposto sobre a venda eh de %f reais" % (imposto_venda))

Quando você executar o programa [Link], sua Janela de Comando exibirá a

seguinta saída:

CotoNet@linux:
O imposto sobre a venda do item eh de 2.757000 reais
 4.12 Lendo uma Entrada de Dados com o Comando input() 43

4.12 Lendo uma Entrada de Dados com o Comando input()

Como vimos anteriormente, a função print() permite exibir mensagens formatadas na
tela, servindo como saída do programa. No entanto, muitos programas também precisam
receber informações do usuário para realizar determinados cálculos ou decisões. Esse
processo é conhecido como entrada de dados.
Imagine que você deseje desenvolver um programa para calcular o Índice de Massa
Corporal (IMC) de uma pessoa. O IMC é calculado pela fórmula:
peso (kg)
IMC = (4.1)
altura (m)2
Para realizar esse cálculo, o programa precisa saber o peso e a altura do usuário. Esses
valores devem ser informados por quem está executando o programa, ou seja, precisam ser
lidos como entrada durante a execução do programa.
A função input() permite fazer uma pergunta ou exibir uma instrução ao usuário,
capturando em seguida a informação digitada no teclado. A sintaxe básica é:

Esquema: print()

nome da variável que irá receber

o valor digitado pelo usuário frase que será impressa na tela

nome = input(’Qual o seu nome? ’)

entre aspas sempre deixe um espaço

depois da frase

O texto passado como argumento da função será exibido no terminal, e o valor digitado
pelo usuário será armazenado na variável especificada. Por padrão, a função input()
retorna sempre uma string (ou seja, um texto). Para utilizar os dados em cálculos
numéricos, é necessário fazer a conversão para o tipo adequado usando int() (para
números inteiros) ou float() (para números decimais), conforme discutido na Seção 3.7.
O programa a seguir, [Link], solicita ao usuário seu nome, idade, peso e altura, e em
seguida calcula e exibe seu IMC:
[Link]
1 nome = input("qual o seu nome? ")
2 idade = int(input("qual a sua idade? "))
3 peso = float(input("qual o seu peso? (em kg) "))
4 altura = float(input("qual a sua altura? (em metros) "))
5 imc = peso/(altura*altura)
6 print("Ola %s, seu IMC eh %.2f" % (nome, imc))

Observe que usamos a função float() para converter os dados de peso e altura, e a
função int() para a idade. Isso permite realizar cálculos numéricos corretamente. Além
disso, o valor do IMC foi formatado para exibir apenas duas casas decimais usando o
marcador %.2f.
 44 Capítulo 4. Entrada e Saída de Dados

Folha de Exercício 1: [Solução da Folha de Exercício 1]

1. Escreva um programa em Python que exiba seu nome com- 7. Escreva um programa em Python que leia o salário de um
pleto na tela. Utilize o comando print para mostrar seu funcionário e calcule o valor de seu novo salário, conside-
nome em uma única linha. rando um aumento de 25%. O programa deve apresentar o
seguinte comportamento:
2. Escreva um programa em Python que solicite ao usuário
um número real utilizando o comando input(), e em se- 8. O valor de um prêmio será dividido entre três ganhadores
guida exiba o quadrado desse número utilizando o comando de um concurso. A distribuição será feita da seguinte forma:
print(). O programa deve apresentar o seguinte comporta- (i) O primeiro ganhador receberá 46% do valor total; (ii)
mento esperado: O segundo ganhador receberá 32% do valor total; e (iii) O
terceiro ganhador ficará com o restante do prêmio. Escreva
3. Escreva um programa em Python que solicite ao usuário um programa em Python que solicite o valor total do prêmio
uma temperatura em graus Celsius e a converta para graus e calcule quanto cada ganhador deverá receber. O programa
Fahrenheit. A fórmula de conversão é dada pela Equação 4.2, deve apresentar o seguinte comportamento:
onde F representa a temperatura em Fahrenheit e C a tem-
peratura em Celsius. O programa deve apresentar o seguinte 9. Escreva um programa em Python que auxilie vendedores.
comportamento no terminal: A partir do valor total de uma venda, o programa deve
! calcular e imprimir: (i) O total a pagar com desconto de
9.0 10%; (ii) O valor de cada parcela, considerando o parcela-
F =C∗ + 32 (4.2)
5.0 mento em 3× sem juros (baseado no valor com desconto);
e (iii) A comissão do vendedor, considerando 5% sobre o
valor com desconto. O programa deve apresentar o seguinte
4. Escreva um programa em Python que leia o valor de um
comportamento:
produto e calcule seu valor com desconto, considerando um
desconto de 12% sobre o valor original. O programa deve
10. Escreva um programa em Python que receba o salário-base
apresentar o seguinte comportamento no terminal:
de um funcionário. O programa deve calcular e imprimir:
(i) O valor da gratificação, que corresponde a 5% do salário-
5. Escreva um programa em Python que leia uma temperatura
base; (ii) O valor do imposto de renda, que corresponde a
em graus Kelvin e a converta para graus Celsius. Utilize a
7% do salário-base; e (iii) O salário final a receber, dado pela
Equação 4.3 de conversão, onde C representa a temperatura
soma do salário-base com a gratificação, subtraído o imposto.
em Celsius e K a temperatura em Kelvin. O programa deve
O programa deve apresentar o seguinte comportamento:
apresentar o seguinte comportamento:
C = K − 273.15 (4.3) 11. Escreva um programa em Python para calcular o volume de
um cilindro circular. O volume V é calculado pela Equa-
6. Escreva um programa em Python que leia uma temperatura ção 4.5. Considere r é o raio da base do cilindro; a é a altura
em graus Fahrenheit e a converta para graus Celsius. A do cilindro; e π ≈ 3.1416.
Equação 4.4 apresenta a fórmula de conversão, onde C re-
V = π · r2 · a (4.5)
presenta a temperatura em Celsius e F a temperatura em
Fahrenheit:
F − 32
C= (4.4)
1.8
 4.12 Lendo uma Entrada de Dados com o Comando input() 45

Folha de Exercício 2: [Solução da Folha de Exercício 2]

1. Escreva um programa em Python que leia a largura e o 12. Escreva um programa em Python que leia um tempo em
comprimento de um terreno e calcule sua área. Exiba o minutos e exiba-o formatado como "xh ym".
resultado na tela.
13. Escreva um programa que calcule a força resultante sobre
2. Escreva um programa em Python que leia um valor em um corpo, usando a segunda lei de Newton:
minutos e converta para horas e minutos.
F = m·a
3. Escreva um programa em Python que solicite ao usuário
a idade de uma pessoa em anos e calcule quantos dias ela 14. Calcule a pressão de um gás usando:
viveu (aproximadamente).
nRT
P=
4. Escreva um programa em Python que leia o peso (kg) e V
a altura (m) de uma pessoa e calcule seu IMC usando a Onde R = 8.314
fórmula. Exiba o valor do IMC com duas casas decimais
peso 15. Calcule a energia cinética de um corpo em movimento:
IMC =
altura2
1
Ec = mv 2
2
5. Escreva um programa em Python leia um tempo em segun-
dos e converta para o formato hh:mm:ss.
16. Calcule a energia potencial gravitacional:
6. Escreva um programa em Python que leia dois números in- Ep = m · g · h
teiros e mostre (i) O resultado da divisão inteira; e (ii) O
resto da divisão.
17. Calcule a tensão elétrica de um circuito usando a Lei de
7. Escreva um programa em Python que leia as coordenadas Ohm:
(x1 , y1 ) e (x2 , y2 ) de dois pontos no plano e calcule a distân-
cia entre eles usando a Equação 4.8 V = R·I
p
d= (x2 − x1 )2 + (y2 − y1 )2 (4.6)
18. Calcule a carga elétrica acumulada em um capacitor:

Q = C ·V
8. Escreva um programa em Python que leia o valor de um
capital, a taxa de juros (ao mês) e o tempo de aplicação (em
meses). Calcule o valor final usando juros simples: 19. Calcule a frequência de uma onda a partir da sua velocidade
e comprimento de onda:
M = C(1 + i · t)
v
f=
λ
9. Escreva um programa em Python que receba um número
inteiro positivo qualquer e calcule a soma de todos os seus
20. Calcule a potência dissipada em um resistor:
dígitos.
P = V ·I
10. Escreva um programa em Python para ler as coordenadas
de dois vetores no plano e calcule o produto escalar entre
eles: 21. Calcule a velocidade média de um objeto:

v1 · v2 = x1 x2 + y1 y2 ∆s
v=
∆t

11. Escreva um programa em Python que leia uma hora atual

22. Calcule a variação do comprimento de um corpo submetido
(em formato 24h: horas e minutos separados) e calcule
à dilatação térmica:
quanto tempo falta para completar o dia (23:59).
∆L = L0 · α · ∆T
 46 Capítulo 4. Entrada e Saída de Dados

Folha de Exercício 3: [Solução da Folha de Exercício 3]

1. Escreva um programa em Python que leia a largura e o 12. Escreva um programa em Python que leia um tempo em
comprimento de um terreno e calcule sua área. Exiba o minutos e exiba-o formatado como "xh ym".
resultado na tela.
13. Escreva um programa que calcule a força resultante sobre
2. Escreva um programa em Python que leia um valor em um corpo, usando a segunda lei de Newton:
minutos e converta para horas e minutos.
F = m·a
3. Escreva um programa em Python que solicite ao usuário
a idade de uma pessoa em anos e calcule quantos dias ela 14. Calcule a pressão de um gás usando:
viveu (aproximadamente).
nRT
P=
4. Escreva um programa em Python que leia o peso (kg) e V
a altura (m) de uma pessoa e calcule seu IMC usando a Onde R = 8.314
fórmula. Exiba o valor do IMC com duas casas decimais
15. Calcule a energia cinética de um corpo em movimento:
peso
IMC = (4.7) 1
altura2 Ec = mv 2
2
5. Escreva um programa em Python leia um tempo em segun-
dos e converta para o formato hh:mm:ss. 16. Calcule a energia potencial gravitacional:

6. Escreva um programa em Python que leia dois números in- Ep = m · g · h

teiros e mostre (i) O resultado da divisão inteira; e (ii) O
resto da divisão.
17. Calcule a tensão elétrica de um circuito usando a Lei de
Ohm:
7. Escreva um programa em Python que leia as coordenadas
(x1 , y1 ) e (x2 , y2 ) de dois pontos no plano e calcule a distân- V = R·I
cia entre eles usando a Equação 4.8

p 18. Calcule a carga elétrica acumulada em um capacitor:

d= (x2 − x1 )2 + (y2 − y1 )2 (4.8)
Q = C ·V
8. Escreva um programa em Python que leia o valor de um
capital, a taxa de juros (ao mês) e o tempo de aplicação (em 19. Calcule a frequência de uma onda a partir da sua velocidade
meses). Calcule o valor final usando juros simples: e comprimento de onda:
M = C(1 + i · t) v
f=
λ
9. Escreva um programa em Python que receba um número
inteiro positivo qualquer e calcule a soma de todos os seus 20. Calcule a potência dissipada em um resistor:
dígitos.
P = V ·I
10. Escreva um programa em Python para ler as coordenadas
de dois vetores no plano e calcule o produto escalar entre
21. Calcule a velocidade média de um objeto:
eles:
∆s
v1 · v2 = x1 x2 + y1 y2 v=
∆t

11. Escreva um programa em Python que leia uma hora atual

22. Calcule a variação do comprimento de um corpo submetido
(em formato 24h: horas e minutos separados) e calcule
à dilatação térmica:
quanto tempo falta para completar o dia (23:59).
∆L = L0 · α · ∆T
 5. Matemática Com Python

5.1 O que é uma Biblioteca no Python?

As bibliotecas Python são coleções de módulos e funções reutilizáveis que simplificam
o desenvolvimento de programas, reduzindo a necessidade de escrever código do zero.
Atualmente, existem mais de 530 mil bibliotecas disponíveis [14], voltadas para as mais
diversas finalidades, como: análise e visualização de dados, estatística, ciência de dados,
automação, inteligência artificial, aprendizado de máquina e aprendizado profundo. A
seguir, estão listadas algumas das bibliotecas mais utilizadas:
• numpy - Computação científica e operações matriciais de alto desempenho.
• math - Funções matemáticas básicas e avançadas.
• pylab - Gráficos bidimensionais (interface do matplotlib).
• matplotlib - Criação de figuras e gráficos 2D/3D
• TensorFlow e Keras - prendizado de máquina e redes neurais.
• OpenCV - Processamento de imagens e vídeo em tempo real.
• PyQt5 - Criação de telas e interface gráfica.
• Rich - Saída colorida, tabelas e barras de progresso no terminal.
• Django e Flask - Desenvolvimento web, criação de sites e APIs REST
• pandas - Análise, tratamento e manipulação eficiente de dados estruturados.
5.2 Importação de Bibliotecas
É possível importar um módulo em sua totalidade ou parcialmente. Para importar um
módulo utilizamos o comando import. O programa [Link] importará todas
as funções da biblioteca math.
[Link]
1 import math
2 print([Link](4))

Nesse caso, todas as funções do módulo math ficam disponíveis, mas é necessário utilizar
o nome do módulo como prefixo: Exemplo: print([Link](4)).
 48 Capítulo 5. Matemática Com Python

Para importar apenas funções específicas de um módulo, utilizamos a instrução

from ... import .... Veja o exemplo no programa [Link]:

[Link]
1 from math import sqrt
2 print(sqrt(4))

Nesse caso, apenas a função sqrt() foi importada do módulo math. Note que, ao
importar diretamente a função, não é necessário utilizar o nome do módulo como prefixo
ao chamá-la. Exemplo: print(sqrt(4)).
A importação seletiva (from ... import ...) pode tornar o código mais limpo e
direto, especialmente quando poucas funções de um módulo são utilizadas. No entanto,
deve-se ter cuidado com possíveis conflitos de nomes, principalmente ao importar funções
de diferentes módulos com o mesmo nome. Se bibliotecas diferentes possuem funções com
mesmo nome, mas com comportamento distintos, haverá conflito (nessa situação, ficaria
valendo a função da última importação feita). Em projetos maiores, recomenda-se utilizar
import modulo para manter a clareza e evitar ambiguidades.

5.3 Operações Básicas

As quatro operações básicas podem ser realizadas de forma direta e simples na linguagem
Python. Os operadores utilizados são: soma +, subtração -, multiplicação * e divisão /.
Os valores podem ser inseridos diretamente em expressões, como em 5 + 2, ou atribuídos
a variáveis, como demonstrado no exemplo a seguir:

[Link]
1 a = 5
2 b = 2
3 soma = a + b
4 subtracao = a - b
5 multiplicacao = a * b
6 divisao = a / b
7 print("Resultado entre a e b")
8 print("a + b = %f " % soma)
9 print("a - b = %f " % subtracao)
10 print("a * b = %f " % multiplicacao)
11 print("a / b = %f " % divisao)

CotoNet@linux:
Resultado entre a e b
a + b = 7.000000
a - b = 3.000000
a * b = 10.000000
a / b = 2.500000

5.4 Potenciação
Em Python, a operação de potenciação pode ser realizada de forma direta, sem a necessidade
de importar bibliotecas adicionais. O operador utilizado é **. Para elevar um valor a a
uma potência b, basta utilizar a expressão a**b. Veja o exemplo a seguir:
 5.5 Radiciação 49

[Link]
1 Massa = 2
2 VelocidadeLuz = 300000
3 Energia = Massa * (VelocidadeLuz**2)
4 print("Energia = %f " % Energia)

Também é possível realizar a potenciação utilizando a função pow() da biblioteca math,

como mostrado no exemplo abaixo. Os resultados obtidos são exatamente os mesmos do
exemplo anterior.

[Link]
1 # Importa a funcao pow() da biblioteca math
2 from math import pow
3 Massa = 2
4 VelocidadeLuz = 300000
5 Energia = Massa * pow(VelocidadeLuz,2)
6 print("Energia = %f " % Energia)

Outra operação importante relacionada à exponenciação é o cálculo de potências

com base no número de Euler, representado pela constante e, aproximadamente igual a
2.71828182846 . . . . Essa constante é a base dos logaritmos naturais. Em Python, podemos
calcular expressões da forma ex utilizando a função exp(), também da biblioteca math.
Veja o exemplo:

[Link]
1 import math
2 test_int = 4
3 test_neg_int = -3
4 test_float = 0.00
5 print ([Link](test_int))
6 print ([Link](test_neg_int))
7 print ([Link](test_float))

5.5 Radiciação
A operação de radiciação em Python pode ser realizada por meio da própria operação
de potenciação. Para calcular a raiz quadrada de um valor, basta elevá-lo à potência 12 ,
utilizando o operador **. Outra forma prática de calcular raízes é por meio da função
sqrt(), disponível na biblioteca math, que retorna diretamente a raiz quadrada de um
número positivo.

[Link]
1 import math
2 print("usando a operacao de potenciacao")
3 print(4**(1/2))
4 print("usando a funcao sqrt() da biblioteca math")
5 print([Link](4))
 50 Capítulo 5. Matemática Com Python

CotoNet@linux:
usando a operacao de potenciacao
2.0
usando a funcao sqrt da biblioteca math
2.0

5.6 Operações Inteiras e Arredondamento

O Python oferece suporte a diversas operações com números reais que envolvem conversão
ou arredondamento para números inteiros. Nesta seção, destacamos três funções bastante
utilizadas: floor(), ceil() e round().
• floor(x) - Retorna o maior número inteiro menor ou igual a x (chamado de "piso").
• ceil(x) - Retorna o menor número inteiro maior ou igual a x (chamado de "teto").
• round(x) – Arredonda x para o inteiro mais próximo.
As funções floor() e ceil() estão disponíveis na biblioteca math e devem ser impor-
tadas antes de serem utilizadas no programa. Já a função round() é nativa da linguagem
Python e pode ser usada diretamente. Além de realizar o arredondamento para o inteiro
mais próximo, a função round() também permite especificar a quantidade de casas decimais
desejada, informando esse valor como segundo argumento. Veja o exemplo a seguir:

[Link]
1 import math
2 a = 3.1456
3
4 print([Link](a))
5 print([Link](a))
6 print(round(a))
7 print(round(a,2))
8 print(round(a,3))

CotoNet@linux:
3
4
3
3.15
3.146

5.7 Sequência das Operações

Ao escrever uma expressão matemática em Python contendo várias operações na mesma
linha, a linguagem segue uma ordem de precedência bem definida, semelhante à utilizada
na matemática tradicional. Essa ordem determina quais operações são executadas primeiro,
garantindo consistência nos resultados. A ordem de execução das operações é a seguinte:
• Parênteses ()
• Potenciação **
• Multiplicação * e Divisão / (avaliadas da esquerda para a direita)
• Adição + e Subtração - (avaliadas da esquerda para a direita)
5.7 Sequência das Operações 51

Para ilustrar essa sequência, considere a seguinte expressão:

2 + 3 × 45 ÷ 6 − 2 (5.1)

[Link]
1 print(2+3*4**5/6-2)
 52 Capítulo 5. Matemática Com Python

A avaliação ocorre na seguinte ordem:

45
2+3× −2 =
6
1024
2+3× −2 =
6
3072
2+ −2 =
6
2 + 512 − 2 =

514 − 2 = 512

Portanto, a expressão completa retorna o valor 512. É importante compreender essa

sequência para evitar resultados incorretos em cálculos mais complexos. Quando houver
dúvida, recomenda-se o uso de parênteses para tornar a ordem de avaliação
explícita e melhorar a legibilidade do código.

5.8 Constantes Matemáticas

A biblioteca math do Python fornece um conjunto de constantes fundamentais da mate-
mática. Entre essas constantes estão os valores de π (pi), e (número de Euler) e τ (tau).
Essas constantes podem ser acessadas diretamente após a importação da biblioteca. A
seguir, listamos algumas das principais constantes disponíveis em math:

• [Link] - Representa a constante matemática π ≈ 3.141592 . . . , usada frequentemente

em cálculos envolvendo círculos, trigonometria e integrais.
• math.e - Representa a constante matemática e ≈ 2.718281 . . . , base dos logaritmos
naturais, fundamental em crescimento exponencial, cálculo e estatística.
• [Link] - Representa a constante τ ≈ 6.283185 . . . , definida como 2π. É utilizada
em contextos envolvendo ângulos e círculos completos.
• [Link] - Representa um valor de infinito positivo. Pode ser usado em comparações,
limites ou para inicializar valores máximos.
• [Link] - Representa um valor especial do tipo float que Not a Number (NaN). É
usado quando uma operação matemática não possui um resultado definido, como
0/0 ou a raiz quadrada de um número negativo (sem números complexos).

[Link]
1 import math
2
3 print([Link])
4 print(math.e)
5 print([Link])
6 print([Link])
7 print([Link])
 5.9 Funções Trigonométricas 53

CotoNet@linux:
3.141592653589793
2.718281828459045
6.283185307179586
inf
nan

5.9 Funções Trigonométricas

A biblioteca math, oferece suporte a diversas funções trigonométricas utilizadas em cálculos
científicos e engenharias. Em todas essas funções, os ângulos são tratados em sua forma
de radianos (valor entre − π2 e π2 ). Caso prefira trabalhar com ângulos em graus, utilize
[Link]() para a conversão.
Entre as principais funções trigonométricas estão:
• [Link](x) - Retorna o seno do ângulo x (em radianos).
• [Link](x) - Retorna o cosseno do ângulo x (em radianos).
• [Link](x) - Retorna a tangente do ângulo x (em radianos).
• [Link](x) - Retorna o arco seno de x (em radianos).
• [Link](x) - Retorna o arco cosseno de x (em radianos).
• [Link](x) - Retorna o arco tangente de x (em radianos).
• [Link](x) - Converte um ângulo de graus para radianos.
• [Link](x) - Converte um ângulo de radianos para graus.
π
O exemplo a seguir mostra como calcular o seno, o cosseno e a tangente de 6 radianos
(equivalente a 30 graus). Observe o exemplo do programa [Link].

[Link]
1 import math
2 angulo_graus = 30
3 angulo_radianos = [Link](angulo_graus)
4 print([Link](angulo_radianos))
5 print([Link](angulo_radianos))
6 print([Link](angulo_radianos))

CotoNet@linux:
0.49999999999999994
0.8660254037844387
0.5773502691896257

5.10 Funções Logarítmicas

As funções logarítmicas podem ser utilizadas em Python por meio da função log() da
biblioteca math. A sintaxe log(x, [base]) permite calcular o logaritmo de um número
x em uma base específica. Caso o segundo argumento (a base) seja omitido, a função
calculará o logaritmo natural de x, ou seja, na base e (número de Euler). Observe o
exemplo:
 54 Capítulo 5. Matemática Com Python

[Link]
1 import math
2 valor = 2.5
3 a = [Link](valor) # log natural
4 b = [Link](valor,2) # log base 2
5 c = [Link](valor,10) # log base 10

Embora a função log(x, base) seja bastante versátil, a biblioteca math também oferece
funções específicas para logaritmos em base 2 e base 10, que podem fornecer resultados
mais precisos e eficientes:
• math.log2(x) - Retorna o logaritmo de x na base 2.
• math.log10(x) - Retorna o logaritmo de x na base 10.
5.11 Valor Absoluto
A função abs() retorna o valor absoluto de um número, ou seja, sua distância em relação
ao zero na reta numérica, independentemente do sinal. Em termos simples, o valor absoluto
corresponde ao próprio número se ele for positivo, ou ao seu oposto se for negativo. Essa
função é nativa da linguagem Python, e pode ser aplicada tanto a números inteiros
quanto a números de ponto flutuante.
Além da função abs(), a biblioteca math oferece a função [Link](), que também
retorna o valor absoluto de um número. A diferença principal é que fabs() sempre retorna
um número do tipo float, mesmo quando a entrada é um inteiro. Veja o exemplo a
seguir, que utiliza a função abs() para obter o valor absoluto de um número negativo. Em
seguida, mostramos o uso da função [Link](), que também retorna o valor absoluto,
mas garante que o resultado seja do tipo float:

[Link]
1 import math
2
3 x = -12.23
4
5 # Usando a funcao abs() nativa do Python
6 sol_abs = abs(x)
7 print("Usando abs(): o valor absoluto de %f eh: %f" % (x, sol_abs))
8
9 # Usando a funcao fabs() da biblioteca math
10 sol_fabs = [Link](x)
11 print("Usando [Link](): o valor absoluto de %f eh: %f" % (x, sol_fabs))

5.12 Fatorial
A operação de fatorial é bastante comum em problemas envolvendo combinatória, análise
matemática, estatística e algoritmos de recursão. Em Python, podemos calcular o fatorial
de um número inteiro não-negativo utilizando a função factorial(), que pertence à
biblioteca math. O fatorial de um número natural n, denotado por n!, é definido como o
produto de todos os inteiros positivos menores ou iguais a n:

n! = n × (n − 1) × (n − 2) × · · · × 2 × 1 (5.2)
5.12 Fatorial 55

Por convenção, temos 0! = 1. Veja o exemplo a seguir que calcula o fatorial de 4:

[Link]
1 import math
2
3 n = 4
4 sfat = [Link](4)
5 print("O fatorial de %d eh %d" % (n,sfat))

A função [Link]() só aceita valores inteiros não-negativos. Caso um número

negativo ou um valor não inteiro seja passado como argumento, o Python lançará uma
exceção do tipo ValueError.
 56 Capítulo 5. Matemática Com Python

Folha de Exercício 4: [Solução da Folha de Exercício 4]

1. A velocidade final vf de um corpo em queda livre, a partir do 9. O ângulo em radianos correspondente a um valor em graus
repouso, após cair de uma altura h é dada pela Equação 5.3, pode ser obtido conforme a Equação 5.11. Escreva um
onde g = 9.8 m/s2 . Escreva um programa em Python usando programa que leia um ângulo em graus e exiba o valor
a biblioteca math que leia o valor de h e calcule a velocidade correspondente em radianos, além dos valores de seu seno,
final. cosseno e tangente.
p
vf = 2gh (5.3)
θ = [Link](x) (5.11)
2. A área de um círculo é dada pela Equação 5.4. Escreva um
programa em Python que leia o raio de um círculo e calcule 10. O tempo necessário para que um material radioativo atinja
sua área utilizando [Link]. uma fração f da massa inicial M0 é dado pela Equação 5.12,
A = πr2 (5.4) onde λ é a taxa de decaimento por período. Escreva um
programa em Python que leia f e λ e calcule o tempo t.
3. A energia potencial elástica de uma mola é dada pela Equa-
ln(f )
ção 5.5 , onde k é a constante elástica e x a deformação. t= (5.12)
ln(1 − λ)
Escreva um programa que calcule a energia armazenada em
uma mola.
1 11. O módulo de um número complexo z = a + bj pode ser ob-
E = kx2 (5.5)
2 tido pela Equação 5.13. Escreva um programa que leia os
valores reais a e b, calcule o módulo de z e exiba o resultado
4. O índice de refração n de um meio pode ser obtido pela Lei com duas casas decimais.
de Snell, conforme a Equação 5.6, onde os ângulos estão em
graus. Escreva um programa que leia θ1 e θ2 e calcule n.
p
|z| = a2 + b2 (5.13)
sin(θ1 )
n= (5.6)
sin(θ2 )
12. Na relatividade especial, o fator de Lorentz descreve o efeito
5. O tempo de queda t de um objeto lançado verticalmente da velocidade em várias propriedades físicas quando ela
para cima com velocidade v0 é dado pela Equação 5.7, onde se aproxima da velocidade da luz. Esse fator é dado pela
g = 9,8 m/s2 . Escreva um programa em Python que leia v0 Equação 5.14. Use c = 3 × 108 m/s para a velocidade da luz.
e calcule o tempo até o ponto mais alto da trajetória. Escreva um programa que leia a velocidade v e compute o
v fator de Lorentz.
t= 0 (5.7)
g 1
γ=q (5.14)
2 2
6. A raiz de uma equação do segundo grau ax + bx + c = 0 1 − vc2
pode ser calculada pela Equação 5.8. Escreva um programa
que leia os coeficientes a, b e c, e calcule as raízes reais, se
existirem. 13. A energia cinética relativística de uma partícula é dada pela
√ Equação 5.15, onde γ é o fator de Lorentz e c = 3.0 × 108 m/s.
−b ± b2 − 4ac
x= (5.8) Escreva um programa que leia v (velocidade) e m (massa),
2a e calcule a energia relativística.
7. A distância entre dois pontos (x1 , y1 ) e (x2 , y2 ) no plano é
1
dada pela Equação 5.9. Escreva um programa em Python E = (γ − 1)mc2 , com γ=q (5.15)
que calcule a distância entre dois pontos. 2
1 − vc2
p
d= (x2 − x1 )2 + (y2 − y1 )2 (5.9)
14. Um pêndulo simples tem seu período aproximado dado pela
8. O volume V de uma esfera é calculado pela Equação 5.10. Equação 5.16, onde L é o comprimento do fio e g = 9.8 m/s2 .
Escreva um programa em Python que leia o raio de uma Escreva um programa que calcule o período T para diferentes
esfera e calcule seu volume. valores de L.
4
V = πr3 (5.10)
3
r
L
T = 2π (5.16)
g
 5.12 Fatorial 57

Folha de Exercício 5: [Solução da Folha de Exercício 5]

1. A amplitude de um sinal senoidal com frequência f e tempo Python que leia os valores de m e h e calcule a energia
t pode ser modelada pela Equação 5.33. Escreva um pro- potencial.
grama que leia A0 , f e t, e calcule a amplitude instantânea
A(t) do sinal. Ep = mgh (5.23)

A(t) = A0 · sin(2πf t) (5.17) 8. A equação da borboleta é dada pelas equações paramétri-

cas 5.40 e 5.41. Faça um programa que retorne os valores
2. A fórmula de Heron para a área de um triângulo com lados de x e y para um dado valor t.
a, b e c é dada pela Equação 5.34, onde s = a+b+c
2 . Escreva
t
  
um programa que leia os lados do triângulo e calcule a área. x = sin(t) ecos(t) − 2 cos(4t) − sin5 (5.24)
12
p a+b+c
A= s(s − a)(s − b)(s − c), com s = (5.18)  
t

2 y = cos(t) ecos(t) − 2 cos(4t) − sin5 (5.25)
12
3. A frequência de ressonância f (em Hz) para o circuito ilus-
trado é dada pela Equação 5.35. Escreva um programa em 9. O comprimento s do arco do segmento parabólico BOC é
Python para calcular a frequência de ressonância f . Consi- dado pela Equação 5.42. Escreva um programa que calcule
dere L = 0,2 henrys e C = 2 × 10−6 . o comprimento do arco. Obs: usar o logaritmo natural.
√
1p 2 b2 4a + b2 + 16a2
 
s= b + 16a2 + ln (5.26)
2 8a b

10. A distância d de um ponto (x0 , y0 , z0 ) a um plano Ax + By +

R1 R2
Cz + D = 0 é dada pela Equação 5.43.
V |Ax0 + By0 + Cz0 + D|
d= √ (5.27)
A2 + B 2 + C 2
L C
11. A força de atração gravitacional entre dois corpos de massas
m1 e m2 é dada pela Equação 5.44, onde G = 6.672 × 10−11
N·m2/kg2.
Gm1 m2
F= (5.28)
s
1 R2 C − L r2
f= LC 12 (5.19)
2π R2 C − L
12. A área de um triângulo qualquer cujos lados medem a, b e c
4. A altura máxima h alcançada por um objeto arremessado é dada pela Equação 5.45, onde s = a+b+c
2 .
com uma velocidade v e em um ângulo θ em relação à ho- p
rizontal, desconsiderando a resistência do ar, é dada pela A= s(s − a)(s − b)(s − c) (5.29)
Equação 5.36.
13. Em engenharia eletrotécnica, a relação entre dois valores de
v 2 sin2 (θ)
h= (5.20) potência em decibéis (dB) é dada pela Equação 5.46.
2g
P2
 
dB = 10 log10 (5.30)
5. Um prisma triangular reto tem volume dado pela Equa- P1
ção 5.37, onde a e b são lados da base, C é o ângulo entre
eles (em graus), e h é a altura. Escreva um programa que 14. A densidade ρ de um gás ideal pode ser calculada por meio
leia a, b, C e h e calcule o volume. da Equação 5.47, onde P é a pressão, M a massa molar,
1 R = 8,314 J/mol·K e T a temperatura.
V = ab sin(C) · h (5.21)
2 PM
ρ= (5.31)
6. Em termodinâmica, a entropia S pode ser calculada pela RT
fórmula de Boltzmann, dada na Equação 5.38, onde k =
1,38 × 10−23 J/K e W é o número de microestados. 15. O ângulo entre dois vetores no plano (x1 , y1 ) e (x2 , y2 ) é
dado pela Equação 5.48. Escreva um programa que leia as
S = k ln(W ) (5.22) coordenadas dos vetores e calcule o ângulo θ entre eles (em
graus).
7. A energia potencial gravitacional Ep de um corpo de massa !
m a uma altura h em relação ao solo é dada pela Equa- −1 x1 x2 + y1 y2
θ = cos (5.32)
ção 5.39, onde g = 9.8 m/s2 . Escreva um programa em
p p
x21 + y12 x22 + y22
 58 Capítulo 5. Matemática Com Python

Folha de Exercício 6: [Solução da Folha de Exercício 6]

1. A amplitude de um sinal senoidal com frequência f e tempo Python que leia os valores de m e h e calcule a energia
t pode ser modelada pela Equação 5.33. Escreva um pro- potencial.
grama que leia A0 , f e t, e calcule a amplitude instantânea
A(t) do sinal. Ep = mgh (5.39)

A(t) = A0 · sin(2πf t) (5.33) 8. A equação da borboleta é dada pelas equações paramétri-

cas 5.40 e 5.41. Faça um programa que retorne os valores
2. A fórmula de Heron para a área de um triângulo com lados de x e y para um dado valor t.
a, b e c é dada pela Equação 5.34, onde s = a+b+c
2 . Escreva
t
  
um programa que leia os lados do triângulo e calcule a área. x = sin(t) ecos(t) − 2 cos(4t) − sin5 (5.40)
12
p a+b+c
A= s(s − a)(s − b)(s − c), com s = (5.34)  
t

2 y = cos(t) ecos(t) − 2 cos(4t) − sin5 (5.41)
12
3. A frequência de ressonância f (em Hz) para o circuito ilus-
trado é dada pela Equação 5.35. Escreva um programa em 9. O comprimento s do arco do segmento parabólico BOC é
Python para calcular a frequência de ressonância f . Consi- dado pela Equação 5.42. Escreva um programa que calcule
dere L = 0,2 henrys e C = 2 × 10−6 . o comprimento do arco. Obs: usar o logaritmo natural.
√
1p 2 b2 4a + b2 + 16a2
 
s= b + 16a2 + ln (5.42)
2 8a b

10. A distância d de um ponto (x0 , y0 , z0 ) a um plano Ax + By +

R1 R2
Cz + D = 0 é dada pela Equação 5.43.
V |Ax0 + By0 + Cz0 + D|
d= √ (5.43)
A2 + B 2 + C 2
L C
11. A força de atração gravitacional entre dois corpos de massas
m1 e m2 é dada pela Equação 5.44, onde G = 6.672 × 10−11
N·m2/kg2.
Gm1 m2
F= (5.44)
s
1 R2 C − L r2
f= LC 12 (5.35)
2π R2 C − L
12. A área de um triângulo qualquer cujos lados medem a, b e c
4. A altura máxima h alcançada por um objeto arremessado é dada pela Equação 5.45, onde s = a+b+c
2 .
com uma velocidade v e em um ângulo θ em relação à ho- p
rizontal, desconsiderando a resistência do ar, é dada pela A= s(s − a)(s − b)(s − c) (5.45)
Equação 5.36.
13. Em engenharia eletrotécnica, a relação entre dois valores de
v 2 sin2 (θ)
h= (5.36) potência em decibéis (dB) é dada pela Equação 5.46.
2g
P2
 
dB = 10 log10 (5.46)
5. Um prisma triangular reto tem volume dado pela Equa- P1
ção 5.37, onde a e b são lados da base, C é o ângulo entre
eles (em graus), e h é a altura. Escreva um programa que 14. A densidade ρ de um gás ideal pode ser calculada por meio
leia a, b, C e h e calcule o volume. da Equação 5.47, onde P é a pressão, M a massa molar,
1 R = 8,314 J/mol·K e T a temperatura.
V = ab sin(C) · h (5.37)
2 PM
ρ= (5.47)
6. Em termodinâmica, a entropia S pode ser calculada pela RT
fórmula de Boltzmann, dada na Equação 5.38, onde k =
1,38 × 10−23 J/K e W é o número de microestados. 15. O ângulo entre dois vetores no plano (x1 , y1 ) e (x2 , y2 ) é
dado pela Equação 5.48. Escreva um programa que leia as
S = k ln(W ) (5.38) coordenadas dos vetores e calcule o ângulo θ entre eles (em
graus).
7. A energia potencial gravitacional Ep de um corpo de massa !
m a uma altura h em relação ao solo é dada pela Equa- −1 x1 x2 + y1 y2
θ = cos (5.48)
ção 5.39, onde g = 9.8 m/s2 . Escreva um programa em
p p
x21 + y12 x22 + y22
 6. Controle de Fluxo

6.1 Compreendendo o Teste Condicional IF

À medida que seus programas tornarem-se mais complexos, eles frequentemente executarão
um conjunto de comandos quando a condição for verdadeira, e outro conjunto de comandos
quando a condição for falsa. Ou seja, o programa pode ou não executar um conjunto de
instruções com base de um resultado de uma condição testada. Para atender a esse tipo de
situação, podemos utilizar instruções especiais denominadas estruturas condicionais.

Quando seu programa precisará executar um processamento condicional, você usará o

comando if. O if é uma estrutura de condição que permite avaliar uma expressão e, de
acordo com seu resultado, executar uma determinada ação. A sintaxe do comando if é
como segue:

Esquema: if()
if condição:
comando(s)

A condição que o comando if avalia é formado por uma proposição lógica, na qual
podemos atribuir um valor lógico verdadeiro ou falso. Caso a condição seja verdadeira, o
Python executará o(s) comando(s) que estiver "dentro dela"(com a indentação, espaçamento
que temos abaixo do if para mostrar que as informações fazem parte dele).

Como um exemplo, o comando if a seguir testa se a variável idade é maior que 20. Se
a condição for verdadeira, o programa executará os comandos que fazem parte do bloco if.
Caso contrário, o programa não executa o bloco e continuará sua execução normalmente.
 60 Capítulo 6. Controle de Fluxo

Esquema: if()

minha_idade = 21

usamos a indentação if minha_idade > 20:

ao lado para mostrar
comandos que
as informações que print("Entramos no bloco if") fazem parte do
fazem parte do bloco print("Sua idade eh maior que 20")
bloco if

comandos fora do print("Estamos fora do bloco if")

bloco if print("bye, bye!")

6.2 Efetuando Testes Relacionais

À medida que seus programas ficarem mais complexos, algumas vezes você precisará testar
se um valor é maior que outro, menor que outro, maior ou igual a outro ou menor ou
igual a outro valor. Para ajudá-lo a realizar esses testes, o Python fornece um conjunto de
operadores relacionais. A Tabela 6.1 lista os operadores relacionais do Python.

Operador Descrição
Relacional
> maior que
>= maior ou igual
< menor que
<= menor ou igual
== igual a
!= diferente

Tabela 6.1: Operadores relacionais

6.3 Testando a Igualdade e Diferença

A maioria dos comandos if testará se o valor de uma variável é igual a um valor específico.
Por exemplo, o comando a seguir testa se a variável idade contém o valor 21:

[Link]
1 idade = 21
2
3 if idade == 21:
4 print("A condicao eh verdadeira!")
5 print("A idade eh igual a 21")

O Python usa o sinal de igual duplo (==) nos testes de igualdade. Quando você escrever
testes de igualdade, use o sinal de igual duplo (==) e não o sinal de igual (=) que o Python
usa para uma atribuição. Assim como algumas vezes seus programas precisam testar se
um valor é igual a outro, o Python usa o símbolo != para testar a diferença. O exemplo a
seguir testa se a variável idade não é igual a 21.
 6.4 Conectivos Lógicos 61

[Link]
1 idade = 20
2
3 if idade != 21:
4 print("A condicao eh verdadeira!")
5 print("A idade eh diferente de 21")

6.4 Conectivos Lógicos

As linguagens de programação, como Python, utilizam os conectivos lógicos da lógica
formal na construção de expressões lógicas. Existem dois conectivos lógicos que, mesmo
que não os conheçamos com o nome de conectivos lógicos, utilizamo-os constantemente ao
conversarmos. São eles, o conectivo de conjunção E (and) e disjunção OU (or).
Os conectivos lógicos devem ser entendidos como ferramenta de notação utilizada para
unir duas ou mais expressões, e como resultado da união, forma-se uma nova expressão.

6.5 Conectivo de Conjunção E (and)

O conectivo lógico de conjunção E, une duas proposições lógicas. No Python, o conectivo
de conjunção é representado por and. A tabela 6.2 apresenta a tabela verdade da conjunção
E. Por definição, a conjunção retorna verdade apenas quando todas as proposições forem
verdadeiras.
O exemplo a seguir testa se a variável idade é maior ou igual à 21 E altura maior que
1.5 metros. É recomendado o uso de parênteses para facilitar o entendimento e organização
das proposições compostas.

[Link]
1 idade = 23
2 altura = 1.75
3
4 if (idade >= 21) and (altura > 1.5):
5 print("A idade eh maior igual a 21 anos")
6 print("A altura eh maior a 1.5 metros")

proposição p proposição q p and q

V V V
V F F
F V F
F F F

Tabela 6.2: Tabela verdade do conectivo de conjunção E (and)

6.6 Conectivo de Disjunção OU (or)

O conectivo lógico de disjunção OU, une duas proposições lógicas. No Python, o conectivo
de disjunção é representado por or. A tabela 6.3 apresenta a tabela verdade da conjunção
OU. Por definição, a conjunção retorna falso apenas quando todas as proposições forem
falsa.
 62 Capítulo 6. Controle de Fluxo

O exemplo a seguir testa se a variável idade é menor que 18 OU peso menor que 45
quilos. É recomendado o uso de parênteses para facilitar o entendimento e organização das
proposições compostas.
[Link]
1 idade = 12
2 peso = 46
3
4 if (idade < 18) or (peso < 45):
5 print("A idade eh menor que 18 anos OU peso menor que 45 quilos")

proposição p proposição q p or q
V V V
V F V
F V V
F F F

Tabela 6.3: Tabela verdade do conectivo de conjunção OU (or)

6.7 Estrutura condicional if-elif-else

Vimos anteriormente como testar uma condição com o comando if e executar uma ação
caso a condição seja verdadeira. No entanto, nenhum comportamento específico foi definido
para o caso de a condição não ser satisfeita. Quando isso é necessário, precisamos utilizar
a palavra reservada else. Adicionalmente, se existir mais de uma condição alternativa que
precisa ser verificada, devemos utilizar o elif para avaliar as expressões intermediárias
antes de usar o else.
[Link]
1 idade = int(input("Digite sua idade: "))
2
3 if (idade >= 10) and (idade < 20):
4 print("Voce eh adolescente")
5 elif (idade >= 20) and (idade < 30):
6 print("Voce eh jovem")
7 elif (idade >= 30) and (idade <= 100):
8 print("Voce eh adulto")
9 else:
10 print('Voce ta fazendo hora extra!')

Na linha 2, verificamos se o valor informado está dentro de uma faixa de valores

específica. Caso a condição seja satisfeita, o programa executará a linha 3. Por outro lado,
caso o resultado não seja o esperado, então o programa verificará o próximo condicional,
na linha 4 e, caso ele seja verdadeiro, a linha 5 será executada. O mesmo ocorre para
a verificação da linha 6. Por fim, se nenhuma das condições foi satisfeita, o programa
executará o que é especificado no bloco else.
Estruturas de controle condicionais estão presentes na maioria das linguagens de
programação e representam uma parte fundamental de cada uma delas. Sendo assim, é
muito importante conhecer a sintaxe e o funcionamento dessas estruturas.
 6.7 Estrutura condicional if-elif-else 63

Folha de Exercício 7: [Solução da Folha de Exercício 7]

1. Elabore um programa em Python que leia dois números e 19. Elabore um programa em Python que leia um número in-
utilize o comando if para verificar se o primeiro é maior teiro e utilize o comando if para verificar se ele é divisível
que o dobro do segundo. por 2 e por 3 ao mesmo tempo.
2. Escreva um programa em Python que leia um número inteiro 20. Crie um programa em Python que leia dois números e utilize
e verifique se ele é positivo utilizando o comando if. o comando if para informar se ambos são diferentes de zero.
3. Faça um programa em Python que leia dois números e utilize 21. Faça um programa que leia a idade de uma pessoa e utilize
o comando if para imprimir o maior deles. o comando if para imprimir "Adolescente"se a idade estiver
entre 13 e 17 anos (inclusive).
4. Escreva um programa que peça ao usuário um número in-
teiro e, usando o comando if, imprima "Par"se o número 22. Escreva um programa em Python que leia o preço de um
for par. produto e utilize o comando if para aplicar um desconto
de 5% caso o preço seja maior que 100.
5. Elabore um programa em Python que leia a idade de uma
pessoa e utilize o comando if para verificar se ela é maior 23. Elabore um programa em Python que leia um número e uti-
de idade (18 anos ou mais). lize o comando if para verificar se ele está fora do intervalo
de 0 a 100.
6. Faça um programa em Python que leia uma letra do teclado
e utilize o comando if para verificar se é uma vogal. 24. Escreva um programa em Python que leia três notas de um
aluno e utilize o comando if para informar se todas são
7. Escreva um programa em Python que receba três núme-
acima de 6.
ros inteiros e utilize o comando if para determinar se pelo
menos um deles é negativo. 25. Faça um programa em Python que leia um número inteiro
e utilize o comando if para exibir uma mensagem caso o
8. Desenvolva um programa que leia dois números inteiros e
número seja múltiplo de 10.
utilize o comando if para verificar se ambos são iguais.
26. Faça um programa em Python que leia os lados de um tri-
9. Faça um programa que leia a temperatura em graus Celsius
ângulo (a, b e c) e utilize o comando if para verificar se eles
e utilize o comando if para avisar se está abaixo de zero.
formam um triângulo válido (a soma de dois lados sempre
10. Escreva um programa em Python que leia um número e maior que o terceiro).
utilize o comando if para verificar se ele está entre 10 e 20
27. Elabore um programa em Python que leia três números
(inclusive).
inteiros e, utilizando o comando if, verifique se eles podem
11. Escreva um programa que leia a nota de um aluno e utilize representar os lados de um triângulo retângulo (ou seja, se
o comando if para informar se ele foi aprovado (nota maior satisfazem o Teorema de Pitágoras).
ou igual a 7).
28. Escreva um programa em Python que leia o valor de x e
12. Elabore um programa que leia um número real e utilize o calcule o valor da função f (x) = x2 − 4x + 3. Use o comando
comando if para verificar se ele é igual a zero. if para imprimir se o valor de f (x) é positivo, negativo ou
zero.
13. Faça um programa que leia dois números e utilize o comando
if para verificar se a soma deles é maior que 100. 29. Faça um programa que leia as coordenadas de dois pontos
(x1 , y1 ) e (x2 , y2 ), calcule a distância entre eles e, utilizando
14. Escreva um programa em Python que leia a idade de uma
o comando if, informe se a distância é maior que 10.
pessoa e utilize o comando if para verificar se ela tem di-
reito à meia-entrada (idade menor ou igual a 12 ou maior 30. Elabore um programa em Python que leia um valor para n
ou igual a 60). e, utilizando o comando if, determine se n é um quadrado
perfeito.
15. Escreva um programa em Python que leia dois números
inteiros e utilize o comando if para verificar se pelo menos 31. Escreva um programa em Python que leia um número real
um deles é par. x e, usando o comando if, avalie a seguinte função definida
por partes:
16. Faça um programa que leia um número inteiro e utilize o
comando if para imprimir "Negativo"se o número for menor
que zero. f (x) = x2 , se x < 0 (6.1)

17. Escreva um programa em Python que leia o salário de um = 2x + 1, se x ≥ 0 (6.2)

funcionário e utilize o comando if para conceder um bônus
de 10% caso o salário seja menor que 2000.
32. Faça um programa em Python que leia as notas das três
18. Escreva um programa em Python que leia uma temperatura provas de um aluno, calcule a média e, utilizando o comando
em graus Celsius e utilize o comando if para exibir "Muito if, informe se o aluno foi aprovado (média maior ou igual a
quente"se a temperatura for maior que 35. 7) ou de recuperação (média entre 4 e 7).
 64 Capítulo 6. Controle de Fluxo

Folha de Exercício 8: [Solução da Folha de Exercício 8]

1. Escreva um programa em Python que leia as coordena- podem doar se já tiverem doado sangue alguma vez antes
das (x, y) de um ponto no plano e indique em qual qua- dessa idade. Pesar no mínimo 60kg se for do sexo masculino
drante [primeiro (+, +), segundo (−, +), terceiro (−, −) ou e 50kg se for do sexo feminino. Não podem doar sangue:
quarto (+, −)] esse ponto se encontra. O programa deve quem estiver com febre no dia da doação, quem estiver grá-
aceitar apenas números diferentes de zero. Caso o usuá- vida, e quem estiver amamentando (a menos que o parto
rio digite zero para x ou y, o programa deve imprimir: tenha ocorrido há mais de 12 meses). Crie um programa que
erro, X e/ou Y nao pode ser zero. receba os dados necessários e informe se a pessoa pode ou
não doar sangue, detalhando os motivos caso a doação não
2. Faça um programa em Python que leia o salário de seja possível. Para respostas booleanas, use como entrada
um trabalhador e o valor da prestação de um emprés- os valores sim ou nao. Para o sexo do doador, utilize F para
timo. Se a prestação for maior que 20% do salário, im- feminino e M para masculino.
prima: Empréstimo não concedido. Caso contrário, im-
prima: Empréstimo concedido. 10. Crie um programa em Python que leia dois números (n1 e
n2) e imprima o quadrado do menor número e a raiz qua-
3. Escreva um programa em Python que leia um número in- drada do maior número. Caso os dois números sejam iguais,
teiro entre 1 e 12 e imprima o mês correspondente a esse o programa deve apenas informar: dois numeros iguais.
número (janeiro se 1, fevereiro se 2, e assim por diante). Caso
o usuário digite um número fora do intervalo, o programa 11. Crie um programa em Python que leia a matrícula, as
deve imprimir: Erro, mês inválido. três notas e a frequência de um aluno (em percentual). O
programa deve calcular a média aritmética das notas e, utili-
4. Faça um programa em Python que receba três números e zando as seguintes regras, informar a situação do aluno: Se a
os mostre em ordem crescente. média for maior ou igual a 7.0 e a frequência for pelo menos
5. Escreva um programa em Python que leia um ano e deter- 75%, o aluno está aprovado. Se a média for menor que 4.0
mine se ele é bissexto. Um ano é bissexto se for divisível ou a frequência for inferior a 75%, o aluno está reprovado.
por 400 ou se for divisível por 4 e não for divisível por 100. Caso contrário, o aluno está em recuperação. O programa
Por exemplo: 1988, 1992, 1996. deve exibir o resultado com a matrícula e as informações
calculadas.
6. Escreva um programa em Python que leia uma data e
verifique se ela é válida. O programa deve verificar se o mês 12. Elabore um programa em Python que leia o horário de
está entre 1 e 12, e se o dia existe naquele mês. Note que entrada e saída de um estacionamento (formato hh : mm) e
fevereiro tem 29 dias em anos bissextos e 28 dias em anos calcule o valor a ser pago, sabendo que: Até 1 hora: valor
não bissextos. fixo de R$ 5.00; De 1 até 2 horas: R$ 8.00; De 2 até 4 horas:
R$ 12.00; Acima de 4 horas: R$ 12.00 mais R$ 3.00 por
7. Escreva um programa em Python para avaliar uma função hora extra (ou fração). O programa deve considerar que o
f (x, y) para quaisquer dois valores x e y informados pelo período pode passar da meia-noite e deve mostrar o valor
usuário. A função f (x, y) é definida por: total arredondado para duas casas decimais.
x+y se x≥0 e y≥0 13. Escreva um programa em Python que leia três valores posi-


x+y 2
se x≥0 e y<0 tivos representando os lados de um triângulo e classifique-o


f (x, y) = quanto aos lados e quanto aos ângulos. Quanto aos lados, o
x2 + y se x<0 e y≥0
triângulo pode ser: equilátero (três lados iguais), isósceles


 2 2
x +y se x<0 e y<0
(dois lados iguais) ou escaleno (todos os lados diferentes).
Quanto aos ângulos, o triângulo pode ser: retângulo (pos-
8. A velocidade de um foguete pode ser descrita pela equação sui um ângulo reto de 90◦ ), acutângulo (todos os ângulos
abaixo. Desenvolva um programa em Python para calcular menores que 90◦ ) ou obtusângulo (possui um ângulo maior
v como uma função do tempo t: que 90◦ ). O programa deve utilizar o Teorema de Pitágoras
 e suas variações para determinar a classificação quanto aos
10t2 − 5t se 0 ≤ t < 8
ângulos. Ao final, informe todas as classificações possíveis


624 − 3t se 8 ≤ t < 16

para o triângulo.


v(t) = 36t + 12(t − 16)2 se 16 ≤ t < 26
14. Faça um programa em Python que simule um sistema de
2136 e−0.1(t−26) se t > 26

controle de acesso a um laboratório. O programa deve solici-



0 caso contrário

tar a matrícula e uma senha numérica do usuário. O sistema

possui até cinco usuários cadastrados (matrícula e senha).
9. Você foi contratado para desenvolver um programa de tri- O acesso só deve ser permitido se a matrícula existir e a
agem de doadores de sangue. Os requisitos para doação senha informada corresponder à matrícula. Caso contrário,
são: Ter entre 16 e 69 anos. Pessoas acima de 60 anos só o acesso é negado e uma mensagem deve ser exibida.
 6.7 Estrutura condicional if-elif-else 65

Folha de Exercício 9: [Solução da Folha de Exercício 9]

1. Escreva um programa em Python que leia a idade de uma os em ordem decrescente.

pessoa e informe se ela é criança (idade < 12), adolescente
18. Crie um programa que leia o valor de uma compra e o mé-
(12 ≤ idade < 18), adulta (18 ≤ idade < 60) ou idosa (idade
todo de pagamento (dinheiro, cartão de débito, cartão de
≥ 60).
crédito). Ofereça descontos ou acréscimos: 10% de desconto
2. Faça um programa que leia dois números inteiros e imprima para dinheiro, 5% para débito, e 8% de acréscimo para
o maior, o menor ou informe se ambos são iguais. crédito.
3. Elabore um programa em Python que leia um número inteiro 19. Elabore um programa que leia o número de faltas de um
e informe se ele é positivo, negativo ou igual a zero. aluno e a média de suas notas. Se o aluno tiver mais de 25%
de faltas, está reprovado por falta. Caso contrário, avalie a
4. Escreva um programa que leia três notas de um aluno média: aprovado (média ≥ 7), recuperação (4 ≤ média < 7),
e calcule a média. Com base na média, informe: "apro- reprovado (média < 4).
vado"(média ≥ 7), "recuperação"(4 ≤ média < 7) ou "repro-
vado"(média < 4). 20. Escreva um programa em Python que leia a nota de uma
prova e retorne a menção: SS (nota = 10), MS (8 ≤ nota
5. Faça um programa em Python que leia o preço de um pro- < 10), MM (6 ≤ nota < 8), MI (4 ≤ nota < 6), II (2 ≤ nota
duto e aplique um desconto: 5% se o preço estiver entre < 4), SR (nota < 2).
R$ 100,00 e R$ 200,00; 10% se estiver acima de R$ 200,00;
sem desconto para preços abaixo de R$ 100,00. Informe o 21. Faça um programa em Python que leia três valores e verifi-
valor final. que se formam uma progressão aritmética, uma progressão
geométrica ou nenhuma das duas.
6. Elabore um programa que leia o nome e o sexo de uma pessoa
(M para masculino, F para feminino) e imprima uma sau- 22. Escreva um programa que leia a velocidade de um veículo e
dação personalizada: "Bem-vindo, senhor"ou "Bem-vinda, informe: "Abaixo do limite"se for menor que 50 km/h, "No
senhora". limite"se igual a 50 km/h e "Acima do limite"se for maior.
7. Escreva um programa que leia uma nota e informe o conceito 23. Elabore um programa em Python que leia um número inteiro
correspondente: A (≥ 9), B (≥ 7 e < 9), C (≥ 5 e < 7), D e informe se é par, ímpar, ou múltiplo de 10.
(≥ 3 e < 5), E (< 3).
24. Crie um programa que leia o nome de um aluno e sua nota
8. Crie um programa que leia três lados e informe se eles po- final. Se a primeira letra do nome for entre ’A’ e ’M’ e
dem formar um triângulo. Caso positivo, indique o tipo: a nota for superior a 7, imprima "Prêmio Destaque"; caso
equilátero, isósceles ou escaleno. contrário, imprima "Sem prêmio".
9. Faça um programa que leia a temperatura em graus Celsius 25. Faça um programa em Python que leia a idade e a categoria
e informe se está frio (menor que 15◦ C), agradável (entre de ingresso (meia, inteira, cortesia). Imprima o valor a pa-
15◦ C e 25◦ C) ou quente (acima de 25◦ C). gar: meia (R$ 10,00), inteira (R$ 20,00), cortesia (R$ 0,00).
Se a idade for menor que 6 anos, sempre será cortesia.
10. Escreva um programa que leia o número de horas traba-
lhadas em um mês e calcule o salário. Considere R$ 20,00 26. Escreva um programa que leia a nota de duas provas e a
por hora até 160 horas e R$ 30,00 por hora para horas média da turma. Se a média do aluno for maior que a média
excedentes. Informe o salário final. da turma, imprima "Acima da média"; se igual, imprima
"Na média"; se menor, imprima "Abaixo da média".
11. Crie um programa que leia um número inteiro e informe se
ele é múltiplo de 3, de 5, de ambos ou de nenhum deles. 27. Elabore um programa em Python que leia um número inteiro
de 1 a 7 e informe o dia da semana correspondente. Para
12. Elabore um programa que leia o peso e a altura de uma números fora do intervalo, informe "Número inválido".
pessoa, calcule o IMC e classifique: abaixo do peso (< 18, 5),
peso normal (18, 5 a 24, 9), sobrepeso (25 a 29, 9), obesidade 28. Crie um programa que leia o valor de três lados de um
(≥ 30). triângulo e diga se ele é válido e, se for, se é obtusângulo,
acutângulo ou retângulo.
13. Faça um programa que leia um caractere e informe se é uma
vogal, uma consoante ou um símbolo especial. 29. Escreva um programa que leia um número real e informe se
está no intervalo [0, 25], (25, 50], (50, 75], (75, 100], ou fora
14. Escreva um programa em Python que leia a idade e o tempo desses intervalos.
de contribuição de um trabalhador e verifique se ele pode se
aposentar pelas regras: idade ≥ 65 (homem) ou 62 (mulher), 30. Faça um programa que leia a renda mensal de uma família
e tempo de contribuição ≥ 35 anos (homem) ou ≥ 30 anos e classifique-a: baixa (até R$ 2 000), média (de R$ 2 001 a
(mulher). R$ 6 000), alta (acima de R$ 6 000).
15. Crie um programa que leia o valor de uma dívida e o número 31. Elabore um programa que leia dois números e uma operação
de parcelas. Calcule o valor de cada parcela considerando: aritmética (+, -, *, /). Realize o cálculo conforme a operação
sem juros até 6 vezes, 5% de juros de 7 a 12 vezes, 10% e trate o caso de divisão por zero.
acima de 12 vezes.
32. Escreva um programa em Python que leia um ano e informe
16. Faça um programa que leia o nome de um mês e informe se ele pertence ao século XX (1901 a 2000), XXI (2001 a
a estação do ano correspondente (verão, outono, inverno, 2100) ou outro século.
primavera).
33. Faça um programa que leia um código de produto (inteiro)
17. Escreva um programa que leia três números e determine o e informe o nome do produto correspondente entre 1 e 5.
maior valor, o menor valor e o valor intermediário, exibindo- Para qualquer outro código, informe "Produto inexistente".
 7. Estruturas de Repetição

7.1 Compreendendo as Estruturas de Repetição

À medida que seus programas se tornam mais complexos, muitas vezes é necessário
executar um mesmo conjunto de instruções várias vezes, seja por um número determinado
de repetições ou até que uma condição específica seja atendida. Essa necessidade está
presente nos mais variados tipos de problemas: calcular a média de vários alunos, processar
todas as linhas de um arquivo, gerar relatórios, realizar simulações, navegar em listas de
dados, controlar o fluxo de jogos, entre muitos outros exemplos. Para essas situações, não
seria eficiente nem prático copiar e colar o mesmo trecho de código várias vezes. É aí que
entram as estruturas de repetição, também conhecidas como laços ou loops.
Estruturas de repetição são mecanismos que permitem ao programa executar automati-
camente um bloco de comandos múltiplas vezes, dependendo de uma condição (ou de um
conjunto de condições) previamente estabelecida. O principal objetivo dessas estruturas é
facilitar o processamento de grandes quantidades de dados, automatizar tarefas repetitivas
e deixar os programas mais flexíveis, compactos e legíveis.
Quando um programa repete um ou mais comandos até atingir determinada condição,
dizemos que ele está realizando um processamento iterativo. Cada passagem com-
pleta pelo bloco de comandos repetidos é chamada de iteração. O processo de passar
repetidamente por esse conjunto de comandos é chamado de processamento iterativo.
O uso de laços é fundamental para solucionar problemas que envolvem repetição de
tarefas, como:
• Verificar cada elemento de uma lista para encontrar um valor específico.
• Repetir uma operação matemática até que o resultado atenda a um critério desejado.
• Solicitar e validar informações fornecidas pelo usuário enquanto a entrada for inválida.
• Processar arquivos linha a linha.
• Realizar cálculos estatísticos em grandes conjuntos de dados.
Sem estruturas de repetição, muitos desses problemas exigiriam que o programador escre-
vesse milhares de linhas de código manualmente, uma para cada caso, o que é impraticável
e propenso a erros.
 68 Capítulo 7. Estruturas de Repetição

7.2 Estrutura de Repetição: o laço for com uso do range

O laço for é utilizado quando se deseja percorrer uma sequência de elementos (como listas,
tuplas, dicionários, conjuntos ou strings) ou quando se sabe previamente o número de vezes
que o bloco de comandos deve ser executado. Ele é especialmente útil para manipular
coleções de dados e para repetições contadas. A sintaxe básica do for é:

Esquema: for()
for CONTADOR in range(VALOR_INICIAL, VALOR_PARADA, PASSO):
# Bloco de Código endentado
comando_1
comando_2
...
comando_n

# instrução não endentada

Quando seu programa precisa repetir comandos um número específico de vezes, normal-
mente se utiliza uma variável chamada contador ou variável de controle, que registra o
número de vezes em que o bloco de código endentado do comando for foi executado.
O comando for apresenta três componentes principais:
1. Valor Inicial: atribui à variável de controle o valor inicial.
2. Valor Final: testa o valor da variável de controle para determinar se o programa
já executou o bloco o número desejado de vezes.
3. Passo: incrementa (ou decrementa) a variável de controle a cada iteração.
Durante a execução do laço, o(s) comando(s) especificado(s) serão repetidamente
executados enquanto a condição de parada não for atingida. Por isso, o comando for é
conhecido como laço for. Considere o exemplo a seguir, que exibe os números de 0 a 4:

[Link]
1 for conta in range(0,3,1):
2 print(conta)

CotoNet@linux:
0
1
2

No exemplo acima, a variável conta é a variável de controle do laço. Inicialmente, o

laço for atribui o valor 0 à variável conta. Em seguida, verifica imediatamente se conta
é menor que 5 (condição de parada). Se for verdadeiro, executa o bloco endentado, que
neste caso é apenas print(conta). Após a execução do comando, o laço incrementa a
variável de controle em 1 (conforme definido pelo passo). O teste da condição é repetido, e,
enquanto conta for menor que 5, o laço continuará.
Assim, a cada iteração, o comando print() exibe o valor atual da variável de controle,
produzindo a saída de 0 até 4. Quando conta atinge o valor 4, o teste da condição de
parada falha, encerrando o laço e continua sua execução normalmente após o bloco do for.
No Python, a função range() utilizada nos laços for aceita apenas valores inteiros
para os argumentos de início, fim e passo. Dessa forma, não é possível utilizar diretamente
 7.3 Decrementando Valores 69

valores de ponto flutuante como incremento ou para definir os limites do laço.

7.3 Decrementando Valores

Como você já aprendeu, o comando for permite repetir um ou mais comandos um número
específico de vezes. Além disso, o comando for também possibilita decrementar a variável
de controle. Por exemplo, o comando for a seguir realiza uma contagem regressiva dos
números 5, 4, 3 e assim por diante, até 1:

[Link]
1 for conta in range(3,0,-1):
2 print(conta)

CotoNet@linux:
3
2
1

Observe que o comando for acima é, em essência, o oposto do exemplo apresentado na

Seção 7.2. Neste caso, o laço inicializa a variável de controle conta com um valor alto e,
em cada iteração, decrementa seu valor em uma unidade até atingir o valor de parada.

7.4 Controlando o Incremento

Como você já aprendeu, o laço for permite que seus programas repitam um ou mais
comandos um número específico de vezes. Nas seções anteriores, cada laço for incrementava
ou decrementava a variável de controle em 1 a cada iteração. No entanto, em Python, é
possível especificar qualquer valor para o incremento ou decremento da variável de controle.
Por exemplo, o comando for a seguir incrementa a variável de controle em 6 a cada
repetição do laço:

[Link]
1 for conta in range(0,20,6):
2 print(conta)

CotoNet@linux:
0
6
12
18

Da mesma forma, os exemplos anteriores inicializavam a variável de controle com 0 ou

1. Assim como você pode definir o passo (incremento ou decremento) para qualquer valor,
o Python também permite inicializar a variável de controle com qualquer valor desejado.
O exemplo a seguir utiliza valores personalizados tanto para o início quanto para o passo
do laço:
 70 Capítulo 7. Estruturas de Repetição

[Link]
1 for conta in range(134,-136,-94):
2 print(conta)

CotoNet@linux:
134
40
-54

7.5 Laços for Aninhados

Em Python, é possível utilizar laços for dentro de outros laços for, formando o que
chamamos de laços aninhados. Na prática, não há um limite teórico para a quantidade
de laços que podem ser aninhados, desde que a legibilidade do código seja mantida e os
recursos computacionais permitam. Essa estrutura é especialmente útil quando precisamos
percorrer estruturas de dados multidimensionais, como listas de listas (matrizes), tabelas,
ou quando desejamos criar combinações de elementos entre diferentes coleções.
O funcionamento dos laços aninhados baseia-se na ideia de que, a cada iteração do laço
externo, o laço interno é executado completamente, do início ao fim. Isso significa que o
laço interno “reinicia” para cada novo valor do laço externo. Dessa forma, se o laço externo
percorre m elementos e o laço interno percorre n elementos, o bloco de comandos internos
será executado m × n vezes ao todo. Essa característica é fundamental, por exemplo, em
algoritmos de processamento de matrizes, multiplicação de tabelas, geração de combinações
e análise de dados em duas ou mais dimensões. Considere o exemplo abaixo, onde exibimos
todos os pares ordenados (x, y) com x variando de 0 a 1 e y de 10 a 12:

[Link]
1 for x in range(0,3,1):
2 for y in range(10,13,1):
3 print("x: %d y: %d" %(x,y))

CotoNet@linux:
x: 0 y: 10
x: 0 y: 11
x: 0 y: 12
x: 1 y: 10
x: 1 y: 11
x: 1 y: 12
x: 2 y: 10
x: 2 y: 11
x: 2 y: 12

No exemplo acima, o laço externo controla o valor da variável x, enquanto o laço interno
controla o valor de y. Para cada valor de x, o laço interno percorre todos os valores possíveis
de y, imprimindo cada par ordenado (x, y). É importante notar que o laço interno sempre
executa por completo a cada nova iteração do laço externo. Esse padrão é fundamental
para varrer elementos em tabelas, linhas e colunas de matrizes, ou mesmo para gerar todos
os pares possíveis entre elementos de duas listas distintas.
 7.6 Somatórios e sua Relação com Laços for 71

Além de matrizes, laços aninhados são essenciais em diversas aplicações, como na

geração de tabelas de multiplicação, na varredura de imagens (em que cada pixel é
identificado por suas coordenadas de linha e coluna), em algoritmos de ordenação e busca
em listas bidimensionais, em simulações que envolvem múltiplos parâmetros variando
simultaneamente e na criação de combinações ou permutações de conjuntos.
A estrutura de laços aninhados pode ser estendida para três ou mais níveis, sendo útil,
por exemplo, no processamento de dados tridimensionais, ou em casos mais complexos
envolvendo múltiplos índices. Entretanto, é recomendável atentar para a eficiência e a
legibilidade do código, pois laços aninhados em excesso podem tornar o programa lento e
difícil de compreender.

7.6 Somatórios e sua Relação com Laços for

P
A notação de somatório, representada pelo símbolo , é uma forma compacta de expressar
a soma de uma sequência de termos. Por exemplo, o somatório:
10
X
i
i=1

indica a soma de todos os números inteiros de 1 a 10. Sua forma expandida é:

1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10

De modo geral, a notação bi=a f (i) indica a soma dos valores da expressão f (i) à medida
P

que o índice i varia de a até b, inclusive. Por exemplo, considere a função f (x) = 2x + 1.
Nesse caso, teremos o somatório:
4
X
f (i) = f (1) + f (2) + f (3) + f (4)
i=1
= (2 · 1 + 1) + (2 · 2 + 1) + (2 · 3 + 1) + (2 · 4 + 1)
= 3 + 5 + 7 + 9 = 24

Assim, a soma corresponde à soma dos valores obtidos pela aplicação da função f (x) = 2x+1
para cada valor de x entre 1 e 4.
Existe uma forte analogia entre a notação de somatório e o uso de laços for em
linguagens de programação. O laço for pode ser utilizado para calcular o valor de um
somatório, repetindo uma operação de soma para cada valor do índice. Por exemplo, para
calcular 10
P
i=1 i em Python, podemos usar:

[Link]
1 soma = 0
2 for i in range(1, 11):
3 soma += i
4 print(soma)

Neste exemplo, a variável i assume todos os valores de 1 até 10, e, a cada passo, o
valor de i é adicionado à variável acumuladora soma.
Como segundo exemplo, considere o cálculo do somatório 6k=1 k 2 , ou seja, a soma dos
P

quadrados dos seis primeiros números inteiros. Neste caso, a função é f (k) = k 2 , e a forma
 72 Capítulo 7. Estruturas de Repetição

expandida fica:
6
X
k 2 = 12 + 22 + 32 + 42 + 52 + 62
k=1
= 1 + 4 + 9 + 16 + 25 + 36 = 91

Em Python, esse somatório pode ser implementado da seguinte forma:

[Link]
1 soma = 0
2 for k in range(1, 7):
3 soma += k ** 2
4 print(soma)

Nesse exemplo, o laço for percorre todos os valores de k de 1 até 6, e a cada iteração
adiciona k 2 à variável acumuladora soma. Ao final, o valor impresso corresponde ao
resultado do somatório dos quadrados, isto é, 91.

7.7 Laço for Aninhado e Somatórios Duplos

Em matemática, a notação de somatório duplo é utilizada para representar somas que
dependem simultaneamente de dois índices, permitindo assim o cálculo de valores em duas
dimensões. Esse tipo de notação é muito comum no estudo de matrizes, séries duplas,
álgebra linear, estatística e em diversas áreas das ciências exatas e da engenharia. O
somatório duplo é representado por dois símbolos de soma em sequência, como em:
3 X
X 2
(i + j)
i=1 j=1

Esse somatório indica que, para cada valor de i de 1 a 3, devemos somar os valores da
expressão (i + j) para cada valor de j de 1 a 2. O cálculo segue uma ordem aninhada: para
cada i, percorre-se todos os valores de j. Sua forma expandida é:

(1 + 1) + (1 + 2)
+ (2 + 1) + (2 + 2)
+ (3 + 1) + (3 + 2)
= 2 + 3 + 3 + 4 + 4 + 5 = 21

A ligação entre o somatório duplo e o uso de laços for aninhados em programação é direta:
cada índice do somatório é representado por um laço for, sendo o laço externo responsável
pelo primeiro índice e o laço interno responsável pelo segundo. Veja o exemplo em Python
para calcular o somatório acima:
[Link]
1 soma = 0
2 for i in range(1, 4):
3 for j in range(1, 3):
4 soma += i + j
5 print(soma)
 7.8 Repetindo Comandos Usando o Laço while 73

CotoNet@linux:
2
5
8
12
16
21
21

Observe que a cada iteração do laço externo, o laço interno executa completamente
todos os seus ciclos. Para cada combinação de i e j, o valor i + j é adicionado à variável
acumuladora soma. O comando print(soma) exibe o valor acumulado a cada passo,
permitindo acompanhar o crescimento da soma ao longo das iterações.
Ao final da execução, o valor de soma corresponde exatamente ao resultado do somatório
duplo matemático expandido anteriormente. Esse padrão de laço aninhado pode ser
generalizado para mais de dois índices, permitindo calcular somatórios triplos e operações
em estruturas tridimensionais ou de ordem superior.

7.8 Repetindo Comandos Usando o Laço while

Como você já aprendeu, o comando for permite repetir um ou mais comandos um número
específico de vezes. No entanto, em muitas situações, os programas precisam repetir um
bloco de comandos até que seja satisfeita uma condição específica, que nem sempre está
relacionada a uma contagem conhecida previamente.
Por exemplo, suponha que você deseje ler números digitados pelo usuário e calcular a
soma desses valores. O programa deve continuar solicitando a entrada de novos números
até que o usuário informe um valor especial, como zero, para encerrar a entrada de dados.
Nessa situação, não é possível saber antecipadamente quantos números o usuário irá digitar,
impossibilitando o uso eficiente de um laço for com quantidade fixa de iterações.
Para esse tipo de situação, utiliza-se o laço while. O laço while executa o bloco
de comandos enquanto uma condição especificada for verdadeira. A sintaxe básica é a
seguinte:

Esquema: print()

while (CONDIÇÃO):
# Bloco de Código Endentado
comando_1
comando_2
...
comando_n

# Instrução Não Endentada

Quando o Python encontra um laço while, ele testa a condição especificada. Se a

condição for verdadeira, os comandos dentro do bloco são executados; após a execução, a
condição é testada novamente, e assim sucessivamente, até que a condição se torne falsa.
O programa a seguir, por exemplo, utiliza o laço while para simular a jogada de um
dado de seis faces até que o usuário decida parar, pressionando a tecla n em resposta à
pergunta do programa:
 74 Capítulo 7. Estruturas de Repetição

[Link]
1 import random
2
3 resposta = "s"
4
5 while (resposta == "s" or resposta == "S"):
6 print("\n")
7 print("Simulando uma jogada de dado de seis faces:")
8 numero = int([Link]()*6)
9 print(numero)
10 resposta = input("Jogar novamente? Digite \'s\' para sim: ")

Nesse exemplo, o programa inicializa a variável resposta com a string "s". O laço
while verifica se resposta é igual a "s" ou "S". Se a condição for verdadeira, o bloco de
comandos dentro do laço é executado, simulando a jogada do dado e solicitando uma nova
resposta do usuário. O laço se repetirá enquanto o usuário continuar respondendo "s"
ou "S". Quando o usuário digitar qualquer outro valor, a condição será falsa, o laço será
encerrado e o programa continuará sua execução normalmente.

7.9 Compreendendo o Comando continue do Python

Como você já aprendeu, as estruturas de repetição for e while permitem que seus
programas executem um bloco de comandos repetidamente, de acordo com uma condição
lógica. Em determinadas situações, no entanto, pode ser desejável pular a execução de
uma iteração específica do laço, com base em uma segunda condição estabelecida no corpo
do laço. Nesses casos, utiliza-se o comando continue.

Quando o Python encontra o comando continue dentro de um laço, ele interrompe

imediatamente a execução dos comandos restantes do bloco naquela iteração, e passa para
a próxima iteração do laço. No caso de laços for, o Python avança para o próximo valor
do índice e testa novamente a condição do laço. Para laços while, a condição é reavaliada
antes de prosseguir com a próxima repetição.

Dessa forma, o comando continue permite que determinadas situações dentro do laço
sejam tratadas de modo especial, fazendo com que o fluxo do programa ignore o restante
dos comandos da iteração atual e avance diretamente para a próxima.

Para ilustrar o uso do comando continue, observe o exemplo abaixo. O programa

percorre os números inteiros de 1 a 9 e exibe apenas aqueles que não são múltiplos de 3:

[Link]
1 for i in range(1, 10):
2 if i % 3 == 0:
3 continue
4 print(i)
 7.10 Compreendendo o Comando break do Python 75

CotoNet@linux:
1
2
4
5
7
8

Considere o caso em que o usuário informa três valores entre 0 e 5, e um laço for exibe
todos os números desse intervalo, exceto os digitados, utilizando o comando continue para
ignorá-los:

[Link]
1 exc1 = int(input("Digite o primeiro numero para excluir [0-5]: "))
2 exc2 = int(input("Digite o segundo numero para excluir [0-5]: "))
3 exc3 = int(input("Digite o terceiro numero para excluir [0-5]: "))
4
5 for n in range(0, 6):
6 if n == exc1 or n == exc2 or n == exc3:
7 continue
8 print(n)

CotoNet@linux:
Digite o primeiro numero para excluir [0-5]: 1
Digite o segundo numero para excluir [0-5]: 4
Digite o terceiro numero para excluir [0-5]: 5
0
2
3

7.10 Compreendendo o Comando break do Python

O comando break é utilizado dentro de estruturas de repetição, como os laços for e while,
para interromper imediatamente a execução do laço em que ele se encontra, independente-
mente de a condição final do laço já ter sido atingida ou não. Quando o Python encontra o
comando break, ele encerra o laço atual e o fluxo de execução do programa continua a
partir da primeira linha de código após o laço.

Esse comando é útil quando, durante a execução do laço, ocorre uma condição especial
que exige a finalização antecipada da repetição. Por exemplo, ao buscar um elemento em
uma lista, o laço pode ser interrompido assim que o elemento desejado for encontrado,
evitando iterações desnecessárias. Como exemplo, considere um programa que lê valores
inteiros digitados pelo usuário e encerra o laço assim que o valor 0 for informado.
76 Capítulo 7. Estruturas de Repetição

[Link]
1 while True:
2 numero = int(input("Digite um numero (0 para sair): "))
3 if numero == 0:
4 print("Valor 0 encontrado! Encerrando o laco.")
5 break
6 print("Voce digitou:", numero)

CotoNet@linux:
Digite um numero (0 para sair): 7
Voce digitou: 7
Digite um numero (0 para sair): 0
Valor 0 encontrado! Encerrando o laco.

Neste exemplo, o laço while é infinito devido à condição True. Isso ocorre porque a
expressão True sempre será avaliada como verdadeira, fazendo com que o laço nunca seja
interrompido naturalmente. Dessa forma, o laço só será encerrado de maneira controlada,
quando algum comando especial, como o break, for executado dentro do bloco do laço.
Esse padrão é frequentemente utilizado quando não se sabe antecipadamente o número de
repetições necessárias e o término da repetição depende de uma condição interna definida.
Como mais um exemplo do uso do comando break, considere um programa simples que
solicita ao usuário uma senha para acessar um sistema. O programa permite um número
ilimitado de tentativas, mas encerra o laço assim que a senha correta for digitada:
[Link]
1 senha_correta = "python123"
2
3 while True:
4 senha = input("Digite a senha de acesso: ")
5 if senha == senha_correta:
6 print("Acesso liberado!")
7 break
8 print("Senha incorreta. Tente novamente.")

CotoNet@linux:
Digite a senha de acesso: abc
Senha incorreta. Tente novamente.
Digite a senha de acesso: python123
Acesso liberado!
 7.10 Compreendendo o Comando break do Python 77

Folha de Exercício 10: [Solução da Folha de Exercício 10]

1. Escreva um programa em Python que solicite dez núme- Escreva um programa em Python capaz de simular uma
ros (n1 , n2 , n3 , . . . , n10 ) ao usuário e, em seguida, imprima o partida e calcular o número de tentativas necessárias para
quadrado de cada um desses números. Exemplo: acertar um determinado jogo pré-definido. O usuário deve
informar previamente a combinação sorteada.
2. Escreva um programa em Python que imprima, em ordem
decrescente, todos os números naturais de 100 até 0. Exem- 12. Escreva um programa em Python que, utilizando um laço
plo: for, solicite ao usuário 20 valores inteiros positivos. Ao final,
informe qual foi o maior valor, o menor valor e a média dos
3. Crie um programa em Python que imprima todos os nú-
números digitados.
meros naturais de 1 até 1000. Ao final, o programa deve
calcular e exibir a soma acumulada de todos os números de 13. Elabore um programa em Python que leia uma sequência de
1 até 1000. Exemplo: números inteiros positivos e conte quantos desses números
são múltiplos de 3 ou de 5. O programa deve parar a leitura
4. Crie um programa em Python que solicite um valor j, com
quando for digitado o número zero.
j ∈ N e j > 3. Em seguida, o programa deve solicitar j
números (n1 , n2 , n3 , . . . , nj ) e, ao final, imprimir a média 14. Escreva um programa em Python que leia vários números
aritmética desses valores. Exemplo: inteiros positivos e verifique quantos deles são primos. O
programa deve encerrar quando o valor −1 for informado.
5. Crie um programa em Python que solicite 10 números. Ao
final, o programa deve informar quantos números são pares 15. Escreva um programa em Python que simule um caixa ele-
e quantos são ímpares. Dica: Use o operador % para calcular trônico. O programa deve solicitar ao usuário um valor
o resto da divisão por 2. inteiro positivo e calcular a menor quantidade possível de
cédulas para compor esse valor, usando as notas de 100, 50,
6. Crie um programa em Python que solicite um número n
20, 10, 5 e 2 reais. O programa deve permitir que o usuário
(n ∈ N). O programa deve calcular e imprimir o fatorial de n.
faça novas consultas até digitar o valor zero.
Caso seja informado um valor inválido, o programa deve exi-
bir a mensagem: "erro, o valor deve ser inteiro e positivo!". 16. Crie um programa em Python que utilize um laço while
Utilize apenas a estrutura de repetição for para calcular o para ler notas de alunos e calcule a média. O programa
fatorial, sem usar a função factorial da biblioteca math. deve aceitar notas entre 0.0 e 10.0 e encerrar quando uma
nota fora desse intervalo for digitada. Em seguida, informe
7. A sequência de Fibonacci é definida como uma sequência
a média das notas válidas.
recursiva, onde os dois primeiros termos são x1 = 1 e x2 = 1.
Para n ≥ 3, os termos seguintes são calculados pela Equa- 17. Escreva um programa em Python que gere e exiba a tabu-
ção 7.1. Escreva um programa em Python que receba um ada de multiplicação de um número inteiro informado pelo
número n > 2 e exiba a sequência de Fibonacci até o n-ésimo usuário, para os valores de 1 a 10. O programa deve permitir
termo. Se o valor informado for inválido, o programa deve ao usuário informar novos valores até digitar o valor 0.
exibir uma mensagem de erro.
18. Elabore um programa em Python que leia um número inteiro
xn = xn−1 + xn−2 (7.1) positivo n e exiba todos os divisores de n. O programa deve
repetir o procedimento até o usuário digitar o valor 0.
8. Escreva um programa em Python usando o comando while
19. Crie um programa em Python que leia um número inteiro
que imprima todos os números da sequência −5, −4.5, . . . ,
positivo e verifique se ele é um número perfeito (ou seja, se a
−0.5, 0.5, . . . , 5, excluindo o zero.
soma de seus divisores próprios é igual ao próprio número).
9. Escreva um programa em Python que solicite repetidamente O programa deve repetir o processo até o usuário digitar
um número real n e imprima a raiz quadrada desse número. −1.
O laço deve ser encerrado quando for informado um número
20. Escreva um programa em Python que simule uma calcu-
n ≤ 0.
ladora simples. O programa deve apresentar um menu de
10. Escreva um programa em Python que leia vários núme- operações (adição, subtração, multiplicação e divisão) e so-
ros reais n no intervalo fechado [100, 200]. O programa licitar dois números para realizar a operação escolhida. O
deve terminar quando o valor zero for lido. Ao final, im- usuário pode realizar quantas operações desejar, até optar
prima quantos números dentro do intervalo foram digitados por sair do programa.
e quantos números fora do intervalo (exceto o zero) foram
21. Escreva um programa em Python que leia uma sequência
informados.
de números inteiros e conte quantos deles são positivos, ne-
11. Em um jogo de loteria, o apostador deve selecionar 3 (três) gativos ou zero. O programa encerra quando o valor −999
números distintos de uma lista de inteiros no intervalo for informado.
[0, 100], informando também a ordem dos números sorteados.
 78 Capítulo 7. Estruturas de Repetição

Folha de Exercício 11: [Solução da Folha de Exercício 11]

1. Elabore um programa em Python que calcule a soma dos 9. Elabore um programa em Python que calcule o produto dos
termos da série harmônica descrita pela Equação 7.20, onde números ímpares conforme a Equação 7.30, onde o valor de
o valor de n deve ser informado pelo usuário. n deve ser informado pelo usuário.
n n
X 1 Y
S= (7.2) P= (2k − 1) (7.12)
k
k=1 k=1

2. Elabore um programa em Python que calcule a soma dos 10. Elabore um programa em Python que calcule uma aproxi-
termos quadrados conforme a Equação 7.21, onde o valor mação para o valor de π usando a Equação 7.31, onde o
de n deve ser informado pelo usuário. valor de n deve ser informado pelo usuário.
n
n
(−1)k
X
S= k2 (7.3)
X
π≈4 (7.13)
k=1 2k + 1
k=0

3. Elabore um programa em Python que calcule os termos da

11. Elabore um programa em Python que calcule uma aproxi-
sequência de Fibonacci descrita pelas Equação 7.24, onde o
mação para o número e usando a Equação 7.32, onde o valor
valor de n deve ser informado pelo usuário.
de n deve ser informado pelo usuário.
F1 = 1 (7.4) n
X 1
F2 = 1 (7.5) e≈ (7.14)
k!
k=0
Fn = Fn−1 + Fn−2 para n ≥ 3 (7.6)
12. Elabore um programa em Python que calcule a soma dos
4. Elabore um programa em Python que calcule o fatorial de quadrados dos números ímpares conforme a Equação 7.33,
n, conforme a Equação 7.25, onde o valor de n deve ser onde o valor de n deve ser informado pelo usuário.
informado pelo usuário. n
X
n! = n × (n − 1) × · · · × 2 × 1 (7.7) S= (2k − 1)2 (7.15)
k=1

5. Elabore um programa em Python que calcule a soma alter-

nada conforme a Equação 7.26, onde o valor de n deve ser 13. Elabore um programa em Python que calcule a soma dos
informado pelo usuário. dígitos de todos os números inteiros de 1 até n conforme a
Equação 7.34, onde o valor de n deve ser informado pelo
n
X (−1)k+1 usuário.
S= (7.8)
k n
k=1
X
S= soma dos dígitos de k (7.16)
6. Elabore um programa em Python que calcule a soma dos k=1
termos da série descrita pela Equação 7.27, onde o valor de
n deve ser informado pelo usuário. 14. Elabore um programa em Python que calcule a soma dos
n
termos da série descrita pela Equação 7.35, onde o valor de
X 1 n deve ser informado pelo usuário.
S= (7.9)
k! n
k=0 X k
S= (7.17)
7. Elabore um programa em Python que calcule a soma dos k+1
k=1
termos da progressão aritmética, conforme a Equação 7.28,
onde os valores de a e n devem ser informados pelo usuário. 15. Elabore um programa em Python que calcule o produto dos
n números pares conforme a Equação 7.36, onde o valor de n
deve ser informado pelo usuário.
X
S= [a + (k − 1)a] (7.10)
k=1 n
Y
P= 2k (7.18)
8. Elabore um programa em Python que calcule a soma dos
k=1
termos da progressão geométrica descrita pela Equação 7.29,
onde os valores de n, a1 e q devem ser informados pelo
16. Elabore um programa em Python que calcule a soma dos
usuário.
termos da série descrita pela Equação 7.37, onde o valor de
n−1
X n deve ser informado pelo usuário.
S= a1 q k (7.11)
n
k=0
X k
S= (7.19)
2k − 1
k=1
 7.10 Compreendendo o Comando break do Python 79

Folha de Exercício 12: [Solução da Folha de Exercício 12]

1. Elabore um programa em Python que calcule a soma dos 9. Elabore um programa em Python que calcule o produto dos
termos da série harmônica descrita pela Equação 7.20, onde números ímpares conforme a Equação 7.30, onde o valor de
o valor de n deve ser informado pelo usuário. n deve ser informado pelo usuário.
n n
X 1 Y
S= (7.20) P= (2k − 1) (7.30)
k
k=1 k=1

2. Elabore um programa em Python que calcule a soma dos 10. Elabore um programa em Python que calcule uma aproxi-
termos quadrados conforme a Equação 7.21, onde o valor mação para o valor de π usando a Equação 7.31, onde o
de n deve ser informado pelo usuário. valor de n deve ser informado pelo usuário.
n
n
(−1)k
X
S= k2 (7.21)
X
π≈4 (7.31)
k=1 2k + 1
k=0

3. Elabore um programa em Python que calcule os termos da

11. Elabore um programa em Python que calcule uma aproxi-
sequência de Fibonacci descrita pelas Equação 7.24, onde o
mação para o número e usando a Equação 7.32, onde o valor
valor de n deve ser informado pelo usuário.
de n deve ser informado pelo usuário.
F1 = 1 (7.22) n
X 1
F2 = 1 (7.23) e≈ (7.32)
k!
k=0
Fn = Fn−1 + Fn−2 para n ≥ 3 (7.24)
12. Elabore um programa em Python que calcule a soma dos
4. Elabore um programa em Python que calcule o fatorial de quadrados dos números ímpares conforme a Equação 7.33,
n, conforme a Equação 7.25, onde o valor de n deve ser onde o valor de n deve ser informado pelo usuário.
informado pelo usuário. n
X
n! = n × (n − 1) × · · · × 2 × 1 (7.25) S= (2k − 1)2 (7.33)
k=1

5. Elabore um programa em Python que calcule a soma alter-

nada conforme a Equação 7.26, onde o valor de n deve ser 13. Elabore um programa em Python que calcule a soma dos
informado pelo usuário. dígitos de todos os números inteiros de 1 até n conforme a
Equação 7.34, onde o valor de n deve ser informado pelo
n
X (−1)k+1 usuário.
S= (7.26)
k n
k=1
X
S= soma dos dígitos de k (7.34)
6. Elabore um programa em Python que calcule a soma dos k=1
termos da série descrita pela Equação 7.27, onde o valor de
n deve ser informado pelo usuário. 14. Elabore um programa em Python que calcule a soma dos
n
termos da série descrita pela Equação 7.35, onde o valor de
X 1 n deve ser informado pelo usuário.
S= (7.27)
k! n
k=0 X k
S= (7.35)
7. Elabore um programa em Python que calcule a soma dos k+1
k=1
termos da progressão aritmética, conforme a Equação 7.28,
onde os valores de a e n devem ser informados pelo usuário. 15. Elabore um programa em Python que calcule o produto dos
n números pares conforme a Equação 7.36, onde o valor de n
deve ser informado pelo usuário.
X
S= [a + (k − 1)a] (7.28)
k=1 n
Y
P= 2k (7.36)
8. Elabore um programa em Python que calcule a soma dos
k=1
termos da progressão geométrica descrita pela Equação 7.29,
onde os valores de n, a1 e q devem ser informados pelo
16. Elabore um programa em Python que calcule a soma dos
usuário.
termos da série descrita pela Equação 7.37, onde o valor de
n−1
X n deve ser informado pelo usuário.
S= a1 q k (7.29)
n
k=0
X k
S= (7.37)
2k − 1
k=1
 8. Funções

Na programação, funções são blocos de código que apenas são executados quando são
chamados. O uso de funções é recomendado quando temos uma determinada tarefa que
normalmente precisam ser executadas diversas vezes dentro de uma aplicação. Quando
surge essa necessidade, para que várias instruções não precisem ser repetidas, elas são
agrupadas em uma função, à qual é dado um nome e que poderá ser chamada/executada
em diferentes partes do programa.

8.1 Sintaxe de uma Função

A sintaxe de uma função é definida por três partes: (i) nome, (ii) parâmetros e (iii) corpo,
o qual agrupa uma sequência de comando que executa uma tarefa. Uma função pode ser
declarada em Python usando a palavra reservada def, seguida do nome da função.

Esquema: print()
def nome_da_funcao(var1, var2, ..., varn):
# Bloco de Código endentado da função
comando_1
comando_2
...
comando_n
return vars

# instrução não endentada

Sendo nome_da_funcao o nome que se deseja nomear à função (sem acentos e sem
espaço), var1, var2, varn suas variáveis independentes de entrada da função. A variável
vars representa a saída da função. Utilizamos a parava revervada return para estabelecer
qual será o valor que a função retornará.
Depois de definida a função, para usá-la basta que seu nome seja chamadao, colocando
entre parênteses o(s) valor(es) numérico(s) (dependendo do número de variáveis de entrada).
 82 Capítulo 8. Funções

8.2 Criando uma Função sem Parâmetros

Uma função não precisa de parâmetros. Se precisar, pode-se usar um ou mais parâmetros.
Esses parâmetros definidos na função, como estudamos, são chamados de parâmetros
formais. Eles representam as informações passadas para funções e são especificados após o
nome da função, entre parênteses. No código abaixo, temos um exemplo de declaração de
função em Python sem parâmetros:

[Link]
1 # Criando a funcao ola()
2 def ola():
3 print("Ola Mundo!")
4
5 # Chamando a funcao criada:
6 ola()

CotoNet@linux:
Ola Mundo!

8.3 Criando uma Função com Um Parâmetro

No código abaixo, temos um exemplo de declaração de função em Python:

[Link]
1 def hello(meu_nome):
2 print("Ola %s " % meu_nome)
3
4 hello("Lucas Ribeiro")

Essa função, de nome hello(), tem como objetivo imprimir o nome que lhe é passado
por parâmetro (também chamado de argumento). A palavra reservada def, na primeira
linha, explicita a definição da função naquele ponto. Em seguida, entre parênteses, temos
o parâmetro meu_nome. Ainda na mesma linha, observe a utilização dos dois pontos (:),
que indicam que o código identado nas linhas abaixo faz parte da função que está sendo
criada. Aqui, é importante ressaltar que, para respeitar a sintaxe da linguagem, a linha 2
identado em relação à linha 1. Para executar a função, de forma semelhante ao que ocorre
em outras linguagens, devemos simplesmente chamar seu nome e passar os parâmetros
esperados entre parênteses, conforme a linha 4.

CotoNet@linux:
Ola Lucas Ribeiro

8.4 Criando uma Função com Dois ou Mais Parâmetros

Caso seja necessário, também é possível definir funções com vários argumentos, como no
código abaixo:
 8.5 Criando uma Função Retornando Algum Valor 83

[Link]
1 def hello(meu_nome, idade):
2 print("Ola %s, sua idade eh: %d" % (meu_nome,idade))
3
4 hello("Lucas Ribeiro", 24)

Agora, ao invocar essa função, também é necessário informar o segundo parâmetro, que
representa a idade que será impressa após o nome:

CotoNet@linux:
Ola Lucas Ribeiro, sua idade eh: 24

8.5 Criando uma Função Retornando Algum Valor

Assim como podem receber valores de entrada, as funções também podem produzir valores
de saída, provenientes de determinadas operações. Nos exemplos anteriores, apenas
imprimimos um valor com a função print(), sem retornar explicitamente um resultado.
Já no programa a seguir, temos uma função que faz o cálculo do salário e retorna o valor a
ser pago conforme o número de horas trabalhadas.
Na linha 1, a função calcular_pagamento() recebe dois parâmetros, qtd_horas e
valor_hora, que representam, respectivamente, a quantidade de horas a serem calculadas
e o valor da hora. Nas linhas 2 e 3, esses valores são convertidos para o tipo float, pois
eles serão recebidos como string por meio da instrução input.
Na quarta linha, verificamos se a quantidade de horas trabalhadas é menor ou igual a
40. Caso seja verdadeiro, na linha 5 calculamos o valor do salário apenas multiplicando a
quantidade de horas pelo valor de cada hora trabalhada. Se a quantidade for maior que 40
(linha 6), adicionamos ao salário um valor adicional pelas horas extras. Por fim, na linha 9
retornamos o resultado do cálculo (contido na variável salario) com a instrução return.
Primeiramente, solicitamos do usuário as informações necessárias, que serão armaze-
nadas como string e repassadas para a função (linhas 12 e 13). Em seguida, na linha 14,
obtemos o resultado da função e o atribuímos à variável total_salario, que é impressa
na linha 15.

[Link]
1 def calcular_pagamento(qtd_horas, valor_hora):
2 horas = float(qtd_horas)
3 taxa = float(valor_hora)
4 if horas <= 40:
5 salario=horas*taxa
6 else:
7 h_excd = horas - 40
8 salario = 40*taxa+(h_excd*(1.5*taxa))
9
10 return salario
11
12 str_horas= input('Digite as horas: ')
13 str_taxa=input('Digite a taxa: ')
14 total_salario = calcular_pagamento(str_horas,str_taxa)
15 print('O valor de seus rendimentos eh R$',total_salario)
84 Capítulo 8. Funções

CotoNet@linux:
Digite as horas: 40
Digite a taxa: 20
O valor de seus rendimentos e R$ 800.0
 8.5 Criando uma Função Retornando Algum Valor 85

Folha de Exercício 13: [Solução da Folha de Exercício 13]

real e retorne sua raiz quadrada, sem usar a função sqrt().

1. Escreva uma função em Python que receba dois números e
retorne a soma entre eles. 23. Crie uma função em Python que calcule a distância entre
dois pontos no plano cartesiano.
2. Crie uma função em Python que receba um número inteiro
e retorne True se for par e False caso contrário. 24. Implemente uma função em Python que calcule a soma dos
n primeiros números naturais.
3. Implemente uma função em Python que calcule o fatorial
de um número inteiro positivo. 25. Escreva uma função em Python que receba a quantidade
de horas trabalhadas e o valor da hora e retorne o salário
4. Escreva uma função em Python que receba a base e a altura
bruto.
de um triângulo e retorne sua área.
26. Crie uma função em Python que receba uma lista de nú-
5. Crie uma função em Python que receba uma lista de nú-
meros e retorne a média, o maior e o menor valor.
meros e retorne o maior valor presente.
27. Implemente uma função em Python que verifique se uma
6. Implemente uma função em Python que receba três núme-
palavra é um palíndromo.
ros e retorne a média aritmética deles.
28. Escreva uma função em Python que receba um número
7. Escreva uma função em Python que receba um número
inteiro e retorne a soma dos seus dígitos.
real representando graus Celsius e retorne o valor convertido
para Fahrenheit. 29. Crie uma função em Python que receba a altura e a veloci-
dade inicial de lançamento vertical e calcule o tempo total
8. Crie uma função em Python que receba a massa e a acele-
de voo do projétil.
ração e retorne a força resultante (segunda lei de Newton).
30. Implemente uma função em Python que receba a carga
9. Implemente uma função em Python que receba a base e a
elétrica (Coulomb) e a diferença de potencial (V) e calcule
altura de um retângulo e retorne o perímetro e a área.
a energia potencial elétrica.
10. Escreva uma função em Python que receba a velocidade
31. Escreva uma função em Python que receba o tempo de uso
inicial, o tempo e a aceleração de um corpo e retorne a
de uma máquina (em horas) e a potência do motor (em kW)
velocidade final.
e calcule a energia consumida em kWh.
11. Crie uma função em Python que receba um número e
32. Crie uma função em Python que receba o valor de uma
retorne True se ele for primo e False caso contrário.
corrente elétrica I e uma resistência R, e retorne a potência
12. Implemente uma função em Python que receba uma lista dissipada no resistor.
de números e retorne a soma de todos os elementos.
33. Implemente uma função em Python que calcule a altura
13. Escreva uma função em Python que receba o raio de uma máxima atingida por um projétil lançado verticalmente com
esfera e retorne seu volume. velocidade inicial v0 , desconsiderando a resistência do ar.
14. Crie uma função em Python que receba dois números com- 34. Escreva uma função em Python que receba uma lista de
plexos e retorne a soma e o produto entre eles. temperaturas em graus Celsius e retorne outra lista conver-
tida para graus Kelvin.
15. Implemente uma função em Python que receba a distância
(m) e o tempo (s) e retorne a velocidade média. 35. Crie uma função em Python que calcule o trabalho reali-
zado por uma força constante F aplicada a um corpo que
16. Escreva uma função em Python que receba um número e
percorreu uma distância d.
retorne sua representação binária.
36. Implemente uma função em Python que calcule a pressão
17. Crie uma função em Python que receba a resistência e a
exercida sobre uma área A por uma força F . Retorne o
corrente elétrica e retorne a tensão usando a Lei de Ohm.
valor em Pascal.
18. Implemente uma função em Python que calcule o índice
37. Escreva uma função em Python que receba um número
de massa corporal (IMC) de uma pessoa a partir da altura
natural n e retorne a soma da série harmônica até o termo
e do peso.
n, ou seja, Hn = 1 + 21 + 13 + · · · + n1 .
19. Escreva uma função em Python que receba um número
38. Crie uma função em Python que receba a distância percor-
inteiro e retorne o seu valor absoluto.
rida (km) e o consumo de combustível (litros) e retorne o
20. Crie uma função em Python que calcule a energia cinética consumo médio em km/l.
de um corpo de massa m e velocidade v.
39. Implemente uma função em Python que calcule a frequên-
21. Implemente uma função em Python que calcule o valor da cia de oscilação de um pêndulo simples de comprimento
p gL e
função quadrática f (x) = ax2 + bx + c para valores fornecidos aceleração da gravidade g, usando a fórmula f = 2π
1
L.
de a, b, c e x.
40. Escreva uma função em Python que receba uma matriz
22. Escreva uma função em Python que receba um número 3 × 3 e retorne o seu determinante.
 86 Capítulo 8. Funções

Folha de Exercício 14: [Solução da Folha de Exercício 14]

1. Implemente uma função em Python que calcule a energia 11. Implemente uma função que calcule o volume de uma esfera,
cinética de uma partícula, definida pela Equação 8.1. conforme a Equação 8.11.
1 4 3
Ec = mv 2 (8.1) V = πr (8.11)
2 3

2. Implemente uma função em Python que calcule a energia 12. Escreva uma função que calcule o centro de massa de um
potencial gravitacional de um corpo em função da altura h, sistema discreto de partículas, Equação 8.12.
conforme a Equação 8.2. mi xi
P
xcm = P (8.12)
Ep = mgh (8.2) mi

3. Crie uma função em Python que calcule a lei de resfria- 13. Crie uma função que calcule o deslocamento angular de um
mento de Newton, conforme a Equação 8.3, onde T (t) é a pêndulo simples para pequenos ângulos, Equação 8.13.
temperatura no tempo t. q
g

θ(t) = θ0 cos t (8.13)
L
T (t) = Ta + (T0 − Ta )e−kt (8.3)
14. Implemente uma função que calcule o número de Reynolds
4. Escreva uma função em Python que calcule a equação da de um escoamento, Equação 8.14.
onda harmônica unidimensional, Equação 8.4, para um dado
ρvD
x e t. Re = (8.14)
µ
y(x, t) = A sin(kx − ωt + ϕ) (8.4)
15. Crie uma função que calcule a potência elétrica dissipada
em um resistor, Equação 8.15.
5. Implemente uma função que calcule a força elástica de uma
mola segundo a Lei de Hooke, Equação 8.5. V2
P= (8.15)
R
F = −kx (8.5)
16. Escreva uma função que calcule a frequência natural de um
6. Escreva uma função que calcule a equação da descarga de sistema massa-mola, Equação 8.16.
um capacitor em um circuito RC, Equação 8.6. r
k
V (t) = V0 e
t
− RC
(8.6) ω0 = (8.16)
m

7. Implemente uma função que calcule a pressão exercida por 17. Desenvolva uma função que calcule a entalpia de um gás
um gás ideal, usando a Equação de Clapeyron (Equação 8.7). ideal, Equação 8.17.

P V = nRT (8.7) H = U +PV (8.17)

8. Escreva uma função que calcule a altura máxima de um 18. Crie uma função que calcule a corrente em um circuito RL
projétil lançado verticalmente, Equação 8.8. em regime transitório, Equação 8.18.

v02 V
 R

hmax = (8.8) i(t) = 1 − e− L t (8.18)
2g R

9. Desenvolva uma função que calcule o trabalho realizado por 19. Escreva uma função que calcule a equação logística do cres-
uma força constante, conforme Equação 8.9. cimento populacional, Equação 8.19.
K
W = F · d · cos(θ) (8.9) P (t) = K−P0
(8.19)
1+


P0 e−rt
10. Crie uma função que calcule a velocidade de um corpo em
20. Implemente uma função que calcule a velocidade de escape
queda livre após um tempo t, conforme Equação 8.10.
de um planeta, Equação 8.20.
v(t) = gt (8.10) r
2GM
ve = (8.20)
R
 8.5 Criando uma Função Retornando Algum Valor 87

Folha de Exercício 15: [Solução da Folha de Exercício 15]

1. Escreva uma função que calcule a energia armazenada em 6. Implemente uma função que calcule o rendimento de uma
um capacitor, Equação 8.21. máquina térmica de Carnot, Equação 8.26.
1 η = 1−
Tc
(8.26)
E= CV 2 (8.21)
2 Tq

2. Crie uma função que calcule a intensidade do campo elétrico 7. Escreva uma função que calcule a velocidade média de um
gerado por uma carga puntiforme, Equação 8.22. móvel, Equação 8.27.
q ∆s
E = ke (8.22) vm = (8.27)
r2 ∆t
3. Implemente uma função que calcule a energia de uma onda 8. Desenvolva uma função que calcule a força centrípeta, Equa-
eletromagnética, Equação 8.23. ção 8.28.
E = hf (8.23) mv 2
Fc = (8.28)
r
4. Desenvolva uma função que calcule a equação do movimento
uniformemente variado (MUV), Equação 8.24. 9. Escreva uma função que calcule a equação da trajetória de
um projétil (movimento oblíquo), Equação 8.29.
1
s(t) = s0 + v0 t + at2 (8.24)
2 gx2
y(x) = x tan(θ) − (8.29)
2v02 cos2 (θ)
5. Escreva uma função que calcule o número de Mach de um
escoamento compressível, Equação 8.25.
10. Crie uma função que calcule a taxa de transmissão de calor
v por condução, Equação 8.30.
M= (8.25)
a
kA(T1 − T2 )
Q= (8.30)
L
 9. Matrizes com NumPy

9.1 A biblioteca NumPy

As matrizes são arranjos numéricos amplamente utilizados na matemática e em diversas
áreas científicas, desempenhando um papel fundamental em disciplinas como álgebra linear,
estatística, física e aprendizado de máquina.
A linguagem de programação Python oferece suporte avançado para essas operações por
meio da biblioteca NumPy. Além disso, disponibiliza uma ampla gama de funções otimizadas
para realizar operações matemáticas, tornando-se essencial para quem trabalha com ciência
de dados, computação científica ou qualquer tarefa que envolva cálculos matriciais.
O NumPy (acrônimo de Numeric Python) é uma biblioteca de extensão para Python,
desenvolvida principalmente em C, o que garante alto desempenho na execução de suas
funções pré-compiladas. Essa biblioteca fornece um conjunto de funções para a manipulação
de arrays e matrizes multidimensionais.
Projetada para lidar com grandes volumes de dados, o NumPy permite trabalhar com
arrays e matrizes de dimensões elevadas, sendo ideal para aplicações em Big Data. Além
disso, oferece uma ampla variedade de funções matemáticas de alto nível, que permitem
operar com essas estruturas de forma prática, eficiente e otimizada.
Para instalar a biblioteca NumPy é necessário executar o seguinte comando:

CotoNet@linux:
python -m pip install numpy

Antes de utilizarmos o NumPy, é necessário importá-lo. Assim como qualquer outro

módulo em Python, ele pode ser importado com o seguinte comando abaixo. Por convenção,
a comunidade utiliza o pseudônimo np para facilitar a chamada das funções durante a
codificação.

[Link]
1 import numpy as np
 90 Capítulo 9. Matrizes com NumPy

9.2 Declarando uma Matriz

A função principal da biblioteca numpy para criar matrizes é array(). Essa função permite
a criação de objetos multidimensionais, amplamente utilizados em cálculos e operações
científicas. Para criar uma matriz com m linhas e n colunas, é necessário organizar seus
elementos conforme o exemplo a seguir:
• Toda matriz deve estar delimitada por colchetes externos.
• Cada linha da matriz deve estar encapsulada por colchetes individuais.
• Os elementos de uma mesma linha devem ser separados por vírgulas.
• Cada linha (exceto a última) deve ser seguida por uma vírgula para separar as linhas
da matriz.
Por exemplo, a matriz A pode ser declara pelo código [Link]
 
1 2 3
A = 4 5 6 (9.1)
 
7 8 9

[Link]
1 import numpy as np
2 A = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
3 print(type(A))
4 print(A)

CotoNet@linux:
<class '[Link]'>
[[1 2 3]
[4 5 6]
[7 8 9]]>

9.3 Declarando uma Matriz com Elementos Iguais

Em muitas situações, é útil criar matrizes de dimensões específicas com valores predefinidos
de forma automática, o que pode agilizar o desenvolvimento de programas e cálculos. A
função ones(), permite criar uma matriz de qualquer dimensão, preenchendo todos os
seus elementos com o valor 1 (um). Essa funcionalidade é especialmente prática em casos
que exigem matrizes inicializadas com valores padrão, como em cálculos matriciais ou
algoritmos que dependem de valores neutros.
Por padrão, os elementos da matriz gerada com ones() serão do tipo float, ideal para
cálculos que exigem maior precisão. No entanto, se for necessário trabalhar com valores
inteiros, basta utilizar o parâmetro opcional dtype=int.
Além da função ones(), o NumPy oferece outras funções que permitem criar matrizes
com valores predefinidos ou personalizados:
• zeros() Cria uma Matriz com todos os elementos iguais a 0 (zero).
• ones() Cria uma Matriz com todos os elementos iguais a 1 (um).
• full() Cria uma Matriz contendo apenas o valor indicado.
 9.4 Gerando um Vetor de Números com Espaçamento Uniforme 91

[Link]
1 import numpy as np
2 M1 = [Link]((2,2))
3 M2 = [Link]((2,2))
4 M3 = [Link]((2,2), 9.5)
5 print("M1 = ", M1)
6 print("M2 = ", M2)
7 print("M3 = ", M3)

CotoNet@linux:
M1 = [[0. 0.]
[0. 0.]]

M2 = [[1. 1.]
[1. 1.]]

M3 = [[9.5 9.5]
[9.5 9.5]]

9.4 Gerando um Vetor de Números com Espaçamento Uniforme

O linspace é uma função utilizada para gerar uma sequência de números distribuídos de
maneira uniforme dentro de um intervalo especificado. O linspace permite especificar
diretamente a quantidade de pontos desejados no intervalo, garantindo espaçamentos iguais
entre eles. A sintaxe básica do linspace é:

Esquema: linspace()
linspace(ini, fim, num)
# onde:
# ini - é o primeiro valor da sequência.
# fim - é o último valor da sequência.
# num - define a quantidade de valores a serem gerados.

Outra maneira de criar vetores com números uniforme é utilizando a função arange.
Essa função gera uma sequência de valores uniformemente espaçados dentro de um intervalo
especificado. Diferente do linspace, que define a quantidade de elementos no intervalo,
o arange permite especificar o incremento entre os valores gerados. A sintaxe básica do
arange é:

Esquema: arange()
arange(ini, fim, pas)
# onde:
# ini - é o primeiro valor da sequência.
# fim - é o último valor da sequência.
# num - determina o espaçamento entre os valores consecutivos.
Se não for especificado, o padrão é 1.
 92 Capítulo 9. Matrizes com NumPy

[Link]
1 import numpy as np
2
3 vetor_linspace = [Link](2, 20, 8)
4 vetor_arrange = [Link](2,34,4)
5 print(vetor_linspace)
6 print(vetor_arrange)

CotoNet@linux:
[ 2. 4.571428 7.142857 9.714285 12.285714 14.857142 17.428571 20.]
[ 2 6 10 14 18 22 26 30]

9.5 Obtendo Propriedades do Array

A biblioteca NumPy permite obter informações fundamentais de um array, tais como sua
geometria e a quantidade total de dados armazenados. Para essa finalidade, destacam-se
as funções shape() e size(), que fornecem esses dados de maneira rápida e eficiente.
• shape: Retorna uma tupla que descreve as dimensões do array. Cada valor da tupla
corresponde ao número de elementos em um eixo (eixo 0 para linhas, eixo 1 para
colunas, etc.). Por exemplo, em uma matriz 3 × 4, este atributo retornaria a tupla
(3, 4), indicando indicando 3 linhas e 4 colunas.
• size: Indica a cardinalidade total do array, ou seja, o número absoluto de elementos
contidos na estrutura, independentemente de sua forma. Para a mesma matriz 3 × 4,
o valor retornado seria 12, resultado do produto das dimensões.

[Link]
1 import numpy
2 M1 = [Link]((2,5))
3 print("M1 = ", M1)
4 print("Total de elementos: %d" % [Link](M1))
5 dim = [Link](M1)
6 print("Dimensao = ", dim)
7 print("M1 tem %d linhas X %d Colunas" % (dim[0], dim[1]))
8 # Outra maneira
9 [linhas,colunas] = [Link](M1)
10 print("M1 tem %d linhas X %d Colunas" % (linhas, colunas))

CotoNet@linux:
M1 = [[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]

Total de elementos: 10

Dimensao = (2, 5)

M1 tem 2 linhas X 5 Colunas

M1 tem 2 linhas X 5 Colunas

 9.6 Acessando Elemento Diretamente do Array 93

9.6 Acessando Elemento Diretamente do Array

Podemos acessar um elemento de uma matriz diretamente, fornecendo seus índices (linha/-
coluna) entre colchetes. Lembre-se de que a indexação em matrizes começa do índice 0, ou
seja, o primeiro elemento tem índice 0, o segundo tem índice 1, e assim por diante.
Para acessar um elemento em uma matriz bidimensional, é necessário especificar primeiro
o índice da linha e, em seguida, o índice da coluna. Por exemplo, para acessar o número 8
na matriz [[2, 3, 4], [9, 8, 7]], indicamos o índice da linha (que é 1, correspondendo
à segunda linha) e, depois, o índice da coluna (que também é 1, correspondendo ao número
8). Dessa forma, conseguimos acessar o segundo elemento da segunda linha dessa matriz.

[Link]
1 import numpy
2 M1 = [Link]([[1, 2, 3],[9, 8, 7]])
3 print("M1 = ", M1)
4 print("Elemento lin:0 col:0: ", M1[0,0])
5 print("Elemento lin:1 col:1: ", M1[1,1])
6 print("Elemento lin:1 col:2: ", M1[1,2])

CotoNet@linux:
M1 = [[1 2 3]
[9 8 7]]
Elemento lin:0 col:0: 1
Elemento lin:1 col:1: 8
Elemento lin:1 col:2: 7

9.7 Acessando Elemento Por Fatiamento em Vetores

O fatiamento é uma técnica utilizada para selecionar uma subseção de um array. Essa
operação é realizada por meio do uso de colchetes e índices, separados por dois pontos
(:). O primeiro índice especifica o ponto de início da seleção, enquanto o segundo índice
define o ponto de parada, excluindo o elemento correspondente a esse índice. Por
exemplo, o comando V[2:5] seleciona os elementos do índice 2 até o índice 4 do array, ou
seja, o elemento no índice 5 não é incluído.
O fatiamento também pode ser utilizado para selecionar uma seção do array a partir
de uma posição específica até o final, ou do início do array até uma posição específica. Por
exemplo, V[2:] seleciona os elementos a partir do índice 2 até o final do array, enquanto
V[:6] seleciona os elementos desde o início até o índice 5, excluindo o índice 6 (ponto de
parada).

[Link]
1 import numpy
2 V = [Link]([9,8,7,6,5,4,3,2,1])
3 print(V)
4 print(V[2:5])
5 print(V[2:])
6 print(V[:6])
 94 Capítulo 9. Matrizes com NumPy

CotoNet@linux:
[9 8 7 6 5 4 3 2 1]
[7 6 5]
[7 6 5 4 3 2 1]
[9 8 7 6 5 4]

9.8 Acessando Elemento Por Fatiamento em Matrizes

É possível utilizar o fatiamento para acessar subarrays dentro de um array. No NumPy, para
realizar o fatiamento de um array multidimensional, é necessário especificar o fatiamento
para cada uma de suas dimensões. Por exemplo, para fatiar um array bidimensional e
selecionar as duas últimas linhas e as três últimas colunas, você pode usar a seguinte
sintaxe no programa [Link].

[Link]
1 import numpy
2 M = [Link]([[1, 2, 3, 4, 5],
3 [6, 7, 8, 9, 10],
4 [11, 12, 13, 14, 15]])
5
6 print('M = \n' , M)
7 print('M = \n' , M[1:3,2:5])

CotoNet@linux:
M =
[[ 1 2 3 4 5]
[ 6 7 8 9 10]
[11 12 13 14 15]]

M =
[[ 8 9 10]
[13 14 15]]

9.9 Maximo e Minimo de Matrizes

O maior e o menor elemento de uma matriz podem ser identificados utilizando os comandos
max() e min(). Esses comandos permitem a identificação dos valores máximos e mínimos
tanto em toda a matriz quanto em partes específicas dela, como por linha ou por coluna,
através de parâmetros opcionais. Ao utilizar o parâmetro 0, a busca pelo valor máximo ou
mínimo será realizada ao longo de cada coluna. Por outro lado, ao especificar o parâmetro
1, a identificação ocorrerá linha por linha, retornando o valor máximo ou mínimo de cada
linha individualmente.
Esses parâmetros oferecem grande versatilidade, permitindo ao usuário realizar análises
mais detalhadas de suas matrizes. O programa [Link] demonstra como
aplicar esses comandos para identificar o maior e o menor elemento considerando a matriz
M , tanto para a matriz completa quanto por linha ou coluna, ilustrando a aplicação dessas
opções na prática.
 9.10 Operadores Aritméticos 95

[Link]
1 import numpy
2 M = [Link]([[11, 2, 3 ],
3 [4, 5, 16 ],
4 [7, 81, 22],
5 [1, 2, 10 ]])
6
7 max_element = [Link](M)
8 min_element = [Link](M)
9 max_por_col = [Link](M,0)
10 max_por_lin = [Link](M,1)
11 max_fatia = [Link](M[:,2])
12 min_fatia = [Link](M[1,:])
13
14 print("Max Global_______: %d " % max_element)
15 print("Min Global_______: %d " % min_element)
16 print("Max por coluna___:", max_por_col)
17 print("Max por linha____:" , max_por_lin)
18 print("Max de uma fatia_:" , max_fatia)
19 print("Min de uma fatia_:" , min_fatia)

CotoNet@linux:
Max Global_______: 81
Min Global_______: 1
Max por coluna___: [11 81 22]
Max por linha____: [11 16 81 10]
Max de uma fatia_: 22
Min de uma fatia_: 4

9.10 Operadores Aritméticos

No NumPy, existem diversas operações aritméticas que podem ser realizadas entre matrizes.
Os mesmos operadores aritméticos descritos na Tabela 3.2 do Capítulo 3, seção 3.9, também
podem ser utilizados para operações com arrays, o que torna a realização dessas operações
simples e intuitiva. Esses operadores, quando aplicados a um array, são realizados elemento
por elemento, ou seja, a operação aritmética é aplicada de forma individual a cada posição
do array, respeitando a estrutura da matriz.
Em outras palavras, ao realizar uma operação como soma, subtração, multiplicação ou
divisão entre arrays, o NumPy executa a operação em cada par de elementos correspondentes
nas matrizes envolvidas. O resultado dessa operação é um novo array, que contém os valores
resultantes da operação aplicada entre os elementos das matrizes originais, mantendo a
estrutura da matriz intacta.
Além disso, esses operadores são extremamente flexíveis e podem ser aplicados tanto
entre um array e um número escalar quanto entre dois arrays. Quando a operação é feita
entre um array e um número escalar, cada elemento do array é manipulado individualmente
com o valor escalar, retornando um novo array com os resultados dessa operação. No caso
de uma operação entre dois arrays, a operação será realizada elemento por elemento, ou
seja, o NumPy calcula a operação para cada par de elementos correspondentes de ambos os
arrays, produzindo um novo array como resultado.
 96 Capítulo 9. Matrizes com NumPy

[Link]
1 import numpy
2 M1 = [Link]([[1, 2, 3], [4, 5, 6]])
3 M2 = [Link]([[6, 5, 4], [3, 2, 1]])
4 print("M_soma = ", M1 + M2)
5 print("M_soma_10", M1 + 10)
6 print("M_sub = ", M1 - M2)
7 print("M_sub_10 = ", M1 - 10)
8 print("M_mult = ", M1 * M2)
9 print("M_div = ", M1 / M2)
10 print("M_div_int = ", M1 // M2)
11 print("M_resto_div = ", M1 % M2)
12 print("M_expo = ", M1 ** M2)

CotoNet@linux:
M_soma = [[ 7 7 7 ]
[ 7 7 7 ]]
M_soma_10 = [[ 11 12 13 ]
[ 14 15 16 ]]
M_sub = [[ -5 -3 -1 ]
[ 1 3 5 ]]
M_sub_10 = [[-9 -8 -7]
[-6 -5 -4]]
M_mult = [[ 6 10 12 ]
[ 12 10 6 ]]
M_div = [[ 0.16 0.4 0.75 ]
[ 1.33 2.5 6.00 ]]
M_div_int = [[0 0 0]
[1 2 6]]
M_resto_div = [[1 2 3]
[1 1 0]]
M_expo = [[ 1 32 81]
[64 25 6]]

9.11 Soma da Elementos

A função sum() do NumPy oferece uma maneira eficiente de somar os elementos de uma
matriz de diferentes formas. Ela pode ser utilizada para calcular a soma de todos os
elementos da matriz de uma só vez, ou para realizar somas mais específicas, seja por linha
ou por coluna. Quando aplicada sem parâmetros adicionais, a função sum() retorna a
soma de todos os elementos da matriz, considerando-a como um único conjunto de dados.
Se for necessário calcular a soma apenas ao longo de uma dimensão específica (como
somar os elementos de cada linha ou de cada coluna), a função permite a especificação de
parâmetros adicionais. Esses parâmetros são semelhantes aos usados em outras funções
como min() e max(), conforme discutido na seção 9.9. Ao fornecer o valor 0 como parâmetro,
a soma será realizada por coluna, ou seja, a função somará os elementos de cada coluna
individualmente, retornando um vetor com os resultados. Por outro lado, ao fornecer o
valor 1 como parâmetro, a soma será realizada por linha, ou seja, cada linha da matriz será
somada separadamente, resultando também em um vetor com os resultados das somas.
 9.12 Operações de Comparação 97

[Link]
1 import numpy
2 M = [Link]([[1, 2, 3],
3 [4, 5, 6],
4 [7, 8, 9]])
5
6 soma_global = [Link](M)
7 soma_lin = [Link](M,1)
8 soma_col = [Link](M,0)
9 soma_fatia = [Link](M[:,2])
10
11 print("Soma Global____: %d" % soma_global)
12 print("Soma linha_____:", soma_lin)
13 print("Soma Coluna____:", soma_col)
14 print("Soma uma fatia_:", soma_fatia)

CotoNet@linux:
Soma Global____: 45
Soma linha_____: [ 6 15 24]
Soma Coluna____: [12 15 18]
Soma uma fatia_: 18

9.12 Operações de Comparação

No NumPy, existem diversos operadores relacionais que podem ser utilizados para realizar
comparações entre matrizes ou arrays. Esses operadores permitem que você faça testes
lógicos entre os elementos das matrizes, facilitando a análise e a manipulação dos dados.
Os mesmos operadores relacionais apresentados na Tabela 6.1 do Capítulo 6, Seção 6.2,
que são utilizados em contextos mais gerais de programação, também podem ser aplicados
diretamente aos arrays no NumPy.

De maneira semelhante aos Operadores Aritméticos discutidos na Seção 9.10, a compa-

ração com operadores relacionais também é feita entre os elementos correspondentes nas
mesmas posições das matrizes envolvidas. Isso significa que o resultado de cada comparação
é armazenado em um novo array de valores booleanos.

[Link]
1 import numpy
2 M1 = [Link]([[1, 5, 7], [1, 2, 6]])
3 M2 = [Link]([[6, 5, 4], [3, 2, 1]])
4 print("M1 == 1", M1 == 1)
5 print("M2 > 5", M2 > 5)
6 print("M1 != M2", M1 != M2)
 98 Capítulo 9. Matrizes com NumPy

CotoNet@linux:
M1 == 1 [[ True False False]
[ True False False]]
M2 > 5 [[ True False False]
[ False False False]]
M1 != M2 [[ True False True]
[ True False True]]

9.13 Criando uma Matriz de Números Aleatórios

O NumPy conta com um submódulo chamado random, que oferece uma série de funções
para a geração de números aleatórios. Esse submódulo permite a criação de números
aleatórios a partir de diversas distribuições, possibilitando a realização de simulações
e modelagens estatísticas avançadas. Dentre as distribuições mais comuns, destacam-
se a distribuição uniforme, que gera números igualmente distribuídos em um intervalo
específico, e a distribuição normal (ou gaussiana), amplamente utilizada em estatísticas e
na modelagem de fenômenos naturais. A seguir, apresentamos algumas dessas funções de
distribuição disponíveis no NumPy:

1. Funções de geração de números aleatórios uniformemente distribuídos:

• [Link](d0,d1,d2,...,dn) - Gera uma matriz de números aleatórios
uniformemente distribuídos no intervalo [0, 1), excluindo o 1.
• [Link](inf,sup,size) - Gera uma matriz de números aleatórios
uniformemente distribuídos dentro do intervalo [inf, sup), excluindo o sup. O Para-
metro size é opcional e pode ser um inteiro ou uma tupla.
2. Funções de geração de números aleatórios normalmente distribuídos:
• [Link](d0,d1,d2,...,dn) - Gera uma matriz de números aleatórios
normalmente distribuídos com média 0 e desvio padrão 1.

A função [Link]() controla o estado do gerador de números aleatórios,

tornando o processo determinístico. Com uma semente definida, a sequência de números
gerados será sempre a mesma. A semente, um número inteiro, serve como ponto de
partida para o algoritmo de números pseudoaleatórios, garantindo a reprodutibilidade dos
resultados. A definição da semente é opcional.

[Link]
1 import numpy
2 M_uniforme_01 = [Link](2,2)
3 M_uniforme_is = [Link](-5,5,(2,2))
4 M_normal_01 = [Link](3,3)
5 M_normal_is = [Link](-5, 5, (2,2))
6 print(M_uniforme_01)
7 print(M_uniforme_is)
8 print(M_normal_01)
9 print(M_normal_is)
 9.14 Percorrendo uma Matriz Bidimensional 99

CotoNet@linux:
M_uniforme_01 = [[0.27312792 0.49716951]
[0.48051376 0.57703322]]

M_uniforme_is = [[ 4.85742697 -3.31932636]

[ 0.58378859 2.02399572]]

M_normal_01 = [[ 0.36561137 0.78305536]

[-0.39548653 1.35272872]]

M_normal_is = [[-2 -1]

[-3 3]]

60

15
50

40

10

30

20
5

10

0 0

(a) rand - Uniformemente distribuídos. (b) randn - Normalmente distribuídos.

Figura 9.1: Histogramas comparativos de 1000 valores.

9.14 Percorrendo uma Matriz Bidimensional

Quando seus programas trabalham com matrizes bidimensionais, é comum utilizar duas
variáveis para acessar os elementos da matriz, uma representando as linhas e a outra
representando as colunas. Isso ocorre porque as matrizes bidimensionais podem ser
visualizadas como tabelas, onde cada elemento é identificado por suas coordenadas, sendo
a primeira coordenada a linha e a segunda a coluna. Para percorrer todos os elementos de
uma matriz bidimensional, geralmente se utiliza um conjunto de loops for aninhados: o
primeiro loop percorre as linhas, e o segundo percorre as colunas de cada linha.
O programa a seguir, [Link], demonstra como usar esses loops aninha-
dos para acessar e exibir todos os elementos de uma matriz. Esse processo permite não
apenas visualizar os elementos, mas também aplicar operações sobre eles, como cálculos
ou transformações. Ao utilizar dois loops for aninhados, o código se torna flexível e
capaz de trabalhar com matrizes de qualquer tamanho, seja para manipulação de dados ou
visualização dos valores contidos na estrutura.
100 Capítulo 9. Matrizes com NumPy

.
[Link]
1 import numpy
2 M = [Link]([[1, 2], [4, 5], [7, 8]])
3
4 for i in range(0,3,1):
5 for j in range(0,2,1):
6 print("lin: %d: col: %d - var: %d " % (i,j,M[i,j]))

[Link]
1 import numpy
2 M = [Link]([[1, 2], [4, 5], [7, 8]])
3
4 for i in range(0,3,1):
5 for j in range(0,2,1):
6 print("lin: %d: col: %d - var: %d " % (i,j,M[i,j]))

CotoNet@linux:
lin: 0: col: 0 - var: 1
lin: 0: col: 1 - var: 2
lin: 1: col: 0 - var: 4
lin: 1: col: 1 - var: 5
lin: 2: col: 0 - var: 7
lin: 2: col: 1 - var: 8

col 0 col 1 col 2

lin 0 a00 a01 a02

lin 1 a10 a11 a12

lin 2 a20 a21 a22

Figura 9.2: Percurso em uma matriz bidimensional utilizando dois laços for aninhados.
As setas representam a ordem de varredura linha a linha, com índices iniciando em (0, 0).

.
9.14 Percorrendo uma Matriz Bidimensional 101

.
 102 Capítulo 9. Matrizes com NumPy

Folha de Exercício 16: [Solução da Folha de Exercício 16]

1. Considere duas matrizes quadradas F [i, j] e G[i, j], onde 6. Calcule o Desvio Absoluto Médio (DAM), de ordem n × n.
i, j ∈ {1, 2, . . . , n}. Crie duas matrizes F e G de ordem n × n, O DAM é definido como a média das diferenças absolutas
preenchidas com números aleatórios gerados por uma distri- entre os elementos da matriz e sua média µ. Esse valor quan-
buição uniforme no intervalo [0, 1). Finalmente, escreva um tifica a dispersão dos dados em relação à média, conforme a
programa em Python para calcular o Erro Médio Abso- Equação 9.9:
luto (EMA) entre essas duas matrizes. O EMA é definido
n n
como a média das diferenças absolutas entre os elementos 1 XX
DAMF = |F [i, j] − µF | (9.8)
correspondentes de F e G, conforme a equação 9.2: n2
i=1 j=1
n n
1 XX n X n
EM A = |F [i, j] − G[i, j]| (9.2) 1 X
n2 DAMG = |G[i, j] − µG | (9.9)
i=1 j=1 n2
i=1 j=1

2. Calcule o Erro Médio Quadrático (EMQ) entre duas matri- Onde µ representa a média dos elementos da matriz.
zes F [i, j] e G[i, j] de ordem n × n. O EMQ é definido como
a média dos quadrados das diferenças entre os elementos 7. Calcule a variância dos elementos das matrizes F e G, am-
correspondentes das duas matrizes. A fórmula matemática bas de ordem n × n. A variância mede a dispersão dos
é apresentada na Equação 9.3: valores em relação à média de cada matriz. As variâncias
n n σF e σG correspondem, respectivamente, às matrizes F e
1 XX
2 G, sendo calculadas pelas Equações 9.10 e 9.11:
EM Q = 2
F [i, j] − G[i, j] (9.3)
n
i=1 j=1 n n
1 XX
2
σF = F [i, j] − µF (9.10)
n2
3. Calcule o Erro Médio Quadrático Normalizado (EMQN) en- i=1 j=1
tre duas matrizes F [i, j] e G[i, j] de ordem n × n. O EMQN n X n
1 X
2
é uma variação do Erro Médio Quadrático (EMQ), em que o σG = G[i, j] − µG (9.11)
n2
resultado é normalizado pelo quadrado dos valores da matriz i=1 j=1
de referência. Ele é calculado conforme a Equação 9.4:
Pn Pn
2
i=1 j=1 F [i, j] − G[i, j] 8. Calcule a covariância entre duas matrizes F e G de ordem
EM QN = (9.4)
Pn Pn
F [i, j]

2 n × n. A covariância σF G mede a relação conjunta entre
i=1 j=1 as variações dos elementos das matrizes F e G em relação
às suas respectivas médias. A fórmula para o cálculo da
4. Calcule o Erro Absoluto Médio Relativo (EMAR) entre duas covariância é dada pela Equação 9.12:
matrizes F [i, j] e G[i, j] de ordem n × n. O EMAR é definido
n n
como a média do valor absoluto do erro relativo entre os 1 XX
σF G = (F [i, j] − µF ) (G[i, j] − µG ) (9.12)
elementos correspondentes das duas matrizes. Sua fórmula n2
está expressa na Equação 9.5: i=1 j=1

n n
1 X X F [i, j] − G[i, j] Onde µF e µG representam as médias das matrizes F e G,
EM AR = (9.5) respectivamente.
n2 F [i, j]
i=1 j=1
9. Calcule o Coeficiente de Correlação entre duas matrizes F e
5. Calcule a média dos elementos das matrizes F e G, ambas de G de ordem n × n. O coeficiente de correlação r quantifica a
ordem n × n. As médias µF e µG correspondem, respectiva- intensidade e a direção da relação linear entre os elementos
mente, à média aritmética dos valores presentes nas matrizes das matrizes F e G. O valor de r varia entre −1 e 1, sendo
F e G. Essas médias são definidas pelas Equações 9.6 e 9.7: calculado conforme a Equação 9.13:
n n
1 XX Pn Pn
µF = F [i, j] (9.6) i=1 j=1 (F [i, j] − µF ) (G[i, j] − µG )
n2 r = qP
i=1 j=1 n Pn 2 Pn Pn 2
n X n i=1 j=1 (F [i, j] − µF ) · i=1 j=1 (G[i, j] − µG )
1 X
µG = G[i, j] (9.7) (9.13)
n2
i=1 j=1
Onde µF e µG representam, respectivamente, as médias das
matrizes F e G.
 9.14 Percorrendo uma Matriz Bidimensional 103

Folha de Exercício 17: [Solução da Folha de Exercício 17]

1. Calcule o Erro Percentual Médio (EPM) entre duas 5. Implemente uma função que identifique, em uma matriz F
matrizes F [i, j] e G[i, j], de ordem n × n. O EPM é defi- de ordem n × m, o índice da linha ou coluna com a maior
nido como a média dos erros percentuais absolutos entre os variância populacional entre seus elementos. A variância é
elementos correspondentes, conforme a Equação 9.14: uma medida da dispersão dos dados em relação à média,
n n e neste caso deve ser calculada de forma populacional,
100 X X F [i, j] − G[i, j] conforme a equação abaixo:
EP M = (9.14)
n2 F [i, j]
i=1 j=1 N
2 1 X
σ = (xi − µ)2 (9.17)
2. Calcule o Coeficiente de Determinação R2 entre duas N
i=1
matrizes F [i, j] e G[i, j], ambas de ordem n × n. O valor de
R2 mede a proporção da variância em F explicada por G, onde:
conforme a Equação 9.15 • N é o número de elementos na linha ou coluna anali-
Pn Pn !2 sada,
2 i=1 j=1 (F [i, j] − µF )(G[i, j] − µG ) • xi representa cada elemento da linha ou coluna,
R = (9.15)
pP
(F [i, j] − µF )2 · (G[i, j] − µG )2
P • µ é a média aritmética dos elementos da linha ou co-
luna.

3. Um quadrado mágico é uma matriz quadrada formada 6. Considere duas matrizes quadradas F e G de ordem n × n.
de números inteiros onde a soma de qualquer coluna, linha, Calcule o traço (tr(M)) de cada uma dessas matrizes e
diagonal principal ou diagonal secundária é sempre o mesmo retorne qual das duas matrizes possui o maior traço (ou
valor. Escreva uma função em Python que receba uma ma- se são iguais). O traço de uma matriz é definido como a
triz quadrada M e determine se M é ou não um quadrado soma dos elementos da sua diagonal principal, expresso pela
mágico. Equação 9.18:
17 24 1 8 15
n
23 5 7 14 16 X
Traço(F) = F [i, i] (9.18)
4 6 13 20 22
i=1
10 12 19 21 3
11 18 25 2 9
7. Implemente uma função em Python que verifique se uma
matriz quadrada F é simétrica. Uma matriz é dita simétrica
4. Implemente uma função em Python para normalizar os va- quando é igual à sua transposta, ou seja, F = FT . Para isso,
lores de uma matriz F para o intervalo [0, 1], utilizando a sua função deve verificar se, para todo par de índices i e j,
técnica de normalização min-max. A normalização min-max a seguinte igualdade é satisfeita: F [i, j] = F [j, i].
garante que o menor valor da matriz seja transformado em 0
e o maior em 1, com todos os demais valores escalados pro- 8. Escreva uma função em Python que determine se uma ma-
porcionalmente dentro desse intervalo. A fórmula utilizada triz quadrada F é uma matriz estocástica por colunas. Uma
para a normalização de cada elemento F [i, j] está definida matriz F é dita estocástica se satisfaz duas condições fun-
na Equação 9.16: damentais: (i) Todos os seus elementos são não negativos:
F [i, j] − Fmin F [i, j] ≥ 0, e, (ii) A soma dos elementos de cada coluna é
Fnorm [i, j] = (9.16)
Fmax − Fmin igual a 1. Esse tipo de matriz é comumente utilizado para
representar cadeias de Markov, em que cada coluna pode
onde:
ser interpretada como uma distribuição de probabilidade
• Fmin representa o menor valor presente na matriz F; condicional. Exemplo de matriz estocástica válida:
• Fmax representa o maior valor presente na matriz F;
• Fnorm [i, j] é o valor normalizado na posição [i, j] da 0.5
"
0.3 0.2
#
nova matriz. F1 = 0.3 0.4 0.3 (9.19)
0.2 0.3 0.5
 104 Capítulo 9. Matrizes com NumPy

Folha de Exercício 18: [Solução da Folha de Exercício 18]

1. Considere uma matriz F de dimensão n × n, contendo nú- Python para aplicar um filtro de mediana utilizando uma
meros reais, onde n ≥ 10. Essa matriz pode representar, por janela 3 × 3. Para cada posição válida (i, j), substitua o valor
exemplo, uma imagem, um mapa de calor ou uma superfície de F[i, j] pela mediana dos 9 elementos vizinhos (incluindo
de dados bidimensionais. O objetivo desta tarefa é suavizar o próprio). Retorne uma nova matriz suavizada Fm . A
os valores da matriz por meio de um filtro de média local função [Link]() calcula a mediana de um vetor.
utilizando uma janela deslizante de dimensão 3 × 3. Para
cada posição válida da janela (sem extrapolar os limites da 3. Crie um programa para aplicar um filtro gaussiano sim-
matriz), calcule a média aritmética dos 9 elementos da sub- plificado em uma matriz F com janela 3 × 3. Utilize o
matriz correspondente. Retorne uma nova matriz Fm com seguinte núcleo de pesos:
os valores suavizados. A matriz resultante terá dimensão
1 2 1
" #
(n − 2) × (n − 2), pois o filtro só pode ser aplicado onde a ja- 1
nela 3 × 3 se encaixa completamente. Exemplo: Considere G= 2 4 2
16
a matriz F de dimensão 10 × 10, preenchida com números 1 2 1
inteiros de 1 a 100:
A equação do filtro aplicado em (i, j) expandido na Equa-
1 2 3 4 5 6 7 8 9 10
 
ção 9.21
11 12 13 14 15 16 17 18 19 20 
21 22 23 24 25 26 27 28 29 30  1
Fm [i, j] = · F [i − 1, j − 1] + 2F [i − 1, j]+
 
31 32 33 34 35 36 37 38 39 40  16
 
41 42 43 44 45 46 47 48 49 50  F [i − 1, j + 1] + 2F [i, j − 1]+
F=
51 52 53 54 55 56 57 58 59 60 
 
4F [i, j] + 2F [i, j + 1]+

61 62 63 64 65 66 67 68 69 70 
71 72 73 74 75 76 77 78 79 80 
  F [i + 1, j − 1] + 2F [i + 1, j]+
81 82 83 84 85 86 87 88 89 90 
F [i + 1, j + 1] (9.21)


91 92 93 94 95 96 97 98 99 100
Escreva um programa em Python que aplique um filtro
de média utilizando uma janela de tamanho 3 × 3. Para 4. Escreva um programa em Python que percorra uma matriz
cada posição válida (i, j), com 1 ≤ i ≤ 8 e 1 ≤ j ≤ 8, o valor F e, para cada posição (i, j), calcule a diferença entre
resultante corresponde à média dos 9 elementos vizinhos o elemento central e a média dos vizinhos da janela
ao redor de F[i, j], incluindo o próprio elemento central. A 3 × 3. Armazene o valor absoluto dessa diferença na posição
Equação 9.20 descreve matematicamente o funcionamento correspondente da nova matriz Fd . A equação pode ser
do filtro de média com janela 3 × 3, aplicado à matriz F. expressa pela Equação 9.22.
1 1 1
Fm [i, j] = F [i − 1, j − 1] + F [i − 1, j]+ 1 X X
9 Fd [i, j] = F [i, j] − F [i + u, j + v] (9.22)
9
F [i − 1, j + 1] + F [i, j − 1]+ u=−1 v=−1
F [i, j] + F [i, j + 1]+
F [i + 1, j − 1] + F [i + 1, j]+ 5. Implemente um filtro que, para cada posição (i, j) de uma
F [i + 1, j + 1] (9.20) matriz F, substitua F[i, j] pela média dos elementos


diagonais da sua vizinhança 3 × 3. A equação do filtro é:
1
Fm [i, j] = · F [i − 1, j − 1] + F [i − 1, j + 1]+
2. Considere uma matriz F de dimensão n × n, com n ≥ 10, 4
preenchida com valores reais. Escreva um programa em F [i + 1, j − 1] + F [i + 1, j + 1] (9.23)


 10. Gráficos com Python

10.1 A biblioteca Matplotlib

O Matplotlib consolidou-se como a bi-
blioteca popular do Python para a ci-
ência de dados e computação científica.
Trata-se de uma ferramenta de código
aberto, projetada para oferecer recursos
avançados de visualização, permitindo
a construção de gráficos bidimensionais
(2D) e tridimensionais (3D).
Originalmente concebido em 2003
por John Hunter, o Matplotlib foi
desenhado como uma extensão do
NumPy. Entre suas inúmeras capacida-
des, destacam-se a geração de: (i) his-
togramas para análise de distribuição,
(ii) gráficos de linha para séries tempo-
rais, (iii) diagramas de dispersão (scat-
ter plots) para correlações e (iv) gráficos
de barras para comparações categóricas.
É importante ressaltar que o
Matplotlib é uma biblioteca de ter-
ceiros; portanto, não acompanham
a instalação do Python. Para
utilizá-lo, é necessário realizar a ins-
talação manual. O gerenciamento
dessa dependência é realizado de
forma simplificada através do geren-
ciador de pacotes pip, utilizando
o seguinte comando no terminal:
 106 Capítulo 10. Gráficos com Python

CotoNet@linux:
python -m pip install matplotlib

10.2 Construindo um Gráfico de Duas Dimensões

O sub-módulo [Link] é uma coleção de funções que permite que o matplotlib
se comporte de maneira similar ao MATLAB, facilitando a criação de gráficos de maneira
intuitiva. Uma das formas mais comuns de criar gráficos bidimensionais é por meio do
uso de pares ordenados de pontos. Para isso, a primeira etapa é a inicialização de dois
vetores, que devem conter o mesmo número de elementos, correspondendo aos valores das
coordenadas x e y dos pontos que serão plotados.
Após armazenarmos os dados nesses vetores, podemos utilizar a função plot() do
pyplot para criar o gráfico. Essa função recebe como argumento os vetores com os dados,
e, ao ser executado, o pyplot gera o gráfico correspondente e o armazena temporariamente
em uma região da memória. O gráfico já está pronto, mas para visualizá-lo em uma janela
de exibição, é necessário executar o comando show(). Esse comando instrui o matplotlib
a renderizar e apresentar o gráfico de maneira interativa.
O programa [Link] tem como objetivo gerar um gráfico de linha simples.
Na terceira linha, é criada uma lista com os nomes dos meses, que serão usados como
valores no eixo X do gráfico. Em seguida, na linha 4, cria-se uma lista de valores numéricos
associados a cada mês. Esses valores serão representados no eixo Y . Por fim, a função
plot é executada, gerando um gráfico de linha que conecta os pontos correspondentes aos
valores dos meses de janeiro a junho. O gráfico gerado é exibido na Figura 10.1.

[Link]
1 import matplotlib
2
3 meses = ["Jan", "Fev", "Mar", "Abr", "Mai", "Jun"]
4 valores = [54, 17, 56, 36, 59, 86]
5 [Link](meses, valores)
6 [Link]()

10.3 Detalhando as Informações no Gráfico

Podemos adicionar informações ao gráfico gerado pelo pyplot para torná-lo mais informa-
tivo. Um dos recursos essenciais é a adição de um título ao gráfico, o que pode ser feito
com a função title. O título ajuda a descrever o objetivo do gráfico ou a contextualizar os
dados apresentados. Além do título, é igualmente importante rotular os eixos x e y. Para
adicionar esses rótulos, utilizamos as função xlabel e ylabel, respectivamente. Dessa
forma, um gráfico bem rotulado torna-se mais acessível, fornecendo informações claras
sobre o que está sendo visualizado.
O programa [Link] é uma versão modificada de [Link]. Logo após
a terceira linha, são utilizadas as funções title, xlabel e ylabel com o objetivo de tornar
o gráfico mais informativo. A função title adiciona o título Faturamento de 2025 ao
gráfico. Já a função xlabel rotula o eixo x com o texto Meses, enquanto ylabel rotula
o eixo y com Faturamento em R$. Em seguida, a função plot traça a linha que conecta
os pontos definidos pelas listas meses e valores. Por fim, a função show exibe o gráfico
resultante, representado na Figura 10.4.
10.3 Detalhando as Informações no Gráfico 107

80
70
60
50
40
30
20
Jan Fev Mar Abr Mai Jun

Figura 10.1: O método plot() é utilizado para criar gráficos de linhas. No gráfico gerado,
os meses são representados na parte horizontal, correspondendo ao eixo X, enquanto os
valores são posicionados na parte vertical, representando o eixo Y .

[Link]
1 import matplotlib
2
3 meses = ["Jan", "Fev", "Mar", "Abr", "Mai", "Jun"]
4 valores = [54, 17, 56, 36, 59, 86]
5 [Link]("Faturamento de 2025")
6 [Link]("Meses")
7 [Link]("Faturamento em R$")
8 [Link](meses, valores)
9 [Link]()

Figura 10.2: O método title(), xlabel() e ylabel() tornam o gráfico mais informativo.
 108 Capítulo 10. Gráficos com Python

10.4 Renomeando a Biblioteca

Observe que, sempre que precisarmos utilizar uma função da biblioteca, devemos especificar
o caminho completo até o módulo, ou seja, [Link], o que pode tornar a
linha de código mais longa e pouco prática. Uma prática comum para simplificar esse
processo é atribuir apelidos aos nossos imports. Por exemplo, podemos informar ao
Python que o módulo pyplot será referenciado pelo apelido plt. Dessa forma, sem-
pre que quisermos utilizar esse módulo, basta chamá-lo pelo apelido, como no exemplo:
import [Link] as plt.

10.5 Inserindo Texto no Gráfico com text()

O comando text() do pacote matplotlib é utilizado para inserir textos diretamente na área
do gráfico, em coordenadas específicas do sistema de eixos. Esse recurso é útil para destacar
informações, rotular pontos, adicionar fórmulas matemáticas ou incluir anotações perso-
nalizadas. A sintaxe básica é: [Link](x, y, "texto", **parâmetros_opcionais).
Nesse comando, x e y correspondem às coordenadas no gráfico onde o texto será inserido,
e "texto" é o conteúdo a ser exibido. Há diversos parâmetros opcionais que permitem
personalizar o estilo e o posicionamento do texto. Alguns dos mais utilizados são:
• fontsize: define o tamanho da fonte.
• color: define a cor do texto (ex.: "black", "red").
• fontfamily: define o tipo de fonte (ex.: "serif", "monospace").
• bbox: adiciona uma caixa ao redor do texto com opções de cor.
[Link]
1 import [Link] as plt
2 import numpy
3
4 x = [Link](0,1,100)
5 y = [Link](x)
6 [Link](x,y)
7 [Link](
8 0.4, 0.2, # Coordenadas (x, y)
9 "Texto personalizado", # Conteudo do texto
10 fontsize=14, # Tamanho da fonte
11 color="white", # Cor do texto
12 fontfamily="monospace", # Tipo da fonte
13 bbox=dict( # Caixa ao redor do texto
14 facecolor="blue", # Cor de fundo da caixa
15 edgecolor="black" # Cor da borda
16 ))
17 [Link]()

10.6 Construindo Gráficos de Dispersão com scatter()

A função scatter() da biblioteca [Link] é utilizada para criar gráficos de
dispersão. Esse tipo de gráfico é ideal para exibir dados como uma coleção de pontos
individuais em um sistema de coordenadas cartesianas. A sintaxe básica da função
é: [Link](x, y), em que x representa os valores do eixo horizontal (eixo x) e y
representa os valores do eixo vertical (eixo y). Por exemplo, o código a seguir cria um
 10.7 Personalização de Gráficos com [Link] 109

Figura 10.3: Comando text() com diversos parâmetros opcionais.

gráfico de dispersão simples:

[Link]
1 import [Link] as plt
2
3 x = [10, 20, 30, 40, 50]
4 y = [15, 25, 35, 30, 45]
5 [Link](x, y)
6 [Link]()

Figura 10.4: oi

10.7 Personalização de Gráficos com [Link]

A biblioteca [Link] oferece uma ampla variedade de opções para personali-
zação de gráficos, tornando-os mais claros e informativos. São dezenas (ou até centenas)
110 Capítulo 10. Gráficos com Python

de parâmetros disponíveis nas diversas funções do pyplot.

No caso da função plot() e scatter(), além dos parâmetros essenciais, é possível
personalizar aspectos visuais, entre eles: (i) a cor da linha, (ii) o estilo da linha, (iii)
o tipo de marcador nos pontos e (iv) a espessura da linha. A Tabela 10.1 apresenta
alguns dos principais parâmetros utilizados na personalização gráfica com a biblioteca
[Link].
O programa [Link] apresenta diversos exemplos de personaliza-
ção gráfica utilizando a biblioteca [Link], por meio das funções plot() e
scatter().
10.7 Personalização de Gráficos com [Link] 111

Tabela 10.1: Resumo de estilos e parâmetros do [Link]

Cores padrão
Cor Atalho Visualização
Preto "k"
Vermelho "r"
Verde "g"
Azul "b"
Ciano "c"
Magenta "m"
Amarelo "y"
Branco "w"
Laranja "tab:orange"
Cinza "0.5"
Estilos de linha
Visual Código Descrição
"-" Linha contínua
"--" Linha tracejada
":" Linha pontilhada
"-." Linha traço-ponto
" " Sem linha (somente marcador)
Parâmetros de personalização
Parâmetro Tipo Descrição
color ou c str Cor da linha ou pontos
linestyle ou ls str Estilo da linha
linewidth ou lw float Espessura da linha
marker str Tipo de marcador
markersize ou ms float Tamanho do marcador
markeredgecolor str Cor da borda do marcador
markerfacecolor str Cor de preenchimento do marcador
markeredgewidth float Espessura da borda
alpha float Transparência (0–1)
Marcadores (markers)
Símbolo Código Descrição
"o" Círculo preenchido
'x' Cruz diagonal
" Linha vertical
"_" Linha horizontal
"+" Cruz reta
"^" Triângulo para cima
"v" Triângulo para baixo
"o" Círculo vazio (markerfacecolor=’none’)

"s" Quadrado
"D" Losango
112 Capítulo 10. Gráficos com Python

[Link]
1 import [Link] as plt
2
3 # Dados base
4 x = [1, 2, 3, 4, 5]
5 y1 = [2, 3, 5, 7, 11]
6 y2 = [1, 4, 6, 8, 9]
7
8 # 1. Grafico de linha padrao
9 [Link]()
10 [Link](x, y1)
11 [Link]('Plot padrao')
12 [Link](True)
13 [Link]()
14
15 # 2. Linha com cor, estilo e marcador
16 [Link]()
17 [Link](x, y1, color="orange", linestyle="--", marker="o", linewidth=2)
18 [Link]('Cor, estilo e marcador')
19 [Link](True)
20 [Link]()
21
22 # 3. Linha com marcadores personalizados
23 [Link]()
24 [Link](x, y1, marker="s", markersize=10, markerfacecolor="blue", markeredgecolor="black")
25 [Link]('Marcador customizado')
26 [Link](True)
27 [Link]()
28
29 # 4. Grafico de dispersao (scatter) padrao
30 [Link]()
31 [Link](x, y2)
32 [Link]('Scatter padrao')
33 [Link](True)
34 [Link]()
35
36 # 5. Scatter com cores, tamanhos e transparencia
37 [Link]()
38 cores = ['red', 'green', 'blue', 'purple', 'orange']
39 tamanhos = [50, 100, 150, 200, 250]
40 [Link](x, y2, c=cores, s=tamanhos, alpha=0.7, edgecolor='black')
41 [Link]('Scatter colorido e transparente')
42 [Link](True)
43 [Link]()
44
45 # 6. Linha e scatter combinados
46 [Link]()
47 [Link](x, y1, linestyle="-.", color="gray", label="Linha")
48 [Link](x, y1, c='red', s=100, marker='D', label="Pontos")
49 [Link]('Plot + Scatter combinados')
50 [Link]()
51 [Link](True)
52 [Link]()
10.7 Personalização de Gráficos com [Link] 113

(a) Gráfico de linha padrão utilizando (b) Linha com cor laranja, estilo
cor azul e estilo de linha simples. tracejado e marcadores circulares.

(c) Linha com marcadores cor azul, (d) Gráfico de dispersão padrão
quadrado com bordas pretas. com pontos azulados.

(e) Gráfico de dispersão com cores variadas, (f) Linha cinza e pontos vermelhos em
tamanhos diferentes e transparência. formato de losango, com legenda.

Figura 10.5: Exemplos de personalização de gráficos com Matplotlib

 114 Capítulo 10. Gráficos com Python

10.8 Inserindo Comandos LATEX

É possível utilizar a escrita de fórmulas matemáticas usando as marcações e comandos
do LATEX. A capacidade de incorporar comandos LATEXé útil para criar gráficos como
de dados científicos, modelagens matemáticas ou análises estatísticas. No Matplotlib, é
possível utilizar a escrita de fórmulas matemáticas diretamente nos gráficos, aproveitando
os poderosos recursos de marcação do LATEX. Isso permite que expressões matemáticas
sejam exibidas com clareza e visualmente elegante. Não é necessário ter o TEX instalado
no computador para que as expressões básicas funcionem; no entanto, para renderizações
mais complexas com recursos específicos do LATEX, a instalação do sistema completo pode
ser necessária.
Para exibir equações matemáticas nos gráficos, basta utilizar a sintaxe r"$ ... $",
que interpreta o conteúdo como código LATEX. Essa abordagem permite a inclusão de
símbolos, fórmulas e notações matemáticas em diversos elementos do gráfico, como títulos,
rótulos de eixos, anotações e legendas. Por exemplo, para exibir a fórmula σ = 23 no eixo x
de um gráfico, utiliza-se o comando [Link](r"$\sigma = 23$"). Essa linha instrui
o Matplotlib a renderizar a string como uma equação matemática, exibindo corretamente
o símbolo σ ao lado do valor numérico.
Também é possível utilizar variáveis dentro de strings de forma dinâmica, o que é espe-
cialmente útil quando desejamos inserir valores numéricos (ou mesmo texto) diretamente
em expressões matemáticas escritas em LATEX. Nesse caso, o valor da variável é automati-
camente inserido na posição indicada dentro da expressão. Para isso, utilizamos o prefixo
fr, que combina uma raw string (essencial para preservar os comandos LATEX) com uma
f-string (para interpolar variáveis). A forma completa seria: fr"$\sigma = {valor}$"
O programa [Link] demonstra a diferença entre o uso de raw strings
(prefixo r) e formatted raw strings (prefixo fr) no Python para a inserção de expressões
matemáticas em gráficos. Já o programa [Link] apresenta um uso mais
avançado desses recursos.
[Link]
1 import [Link] as plt
2 import numpy
3
4 pi = 3.1415926535
5 x = [Link](0,5,100)
6 y = [Link](x)
7 [Link](x,y)
8
9 # Exemplo com f + r (fr): interpolacao de variavel + LaTeX
10 [Link](0, -0.5, fr"Exemplo (fr)_: $\sigma = {pi}$", fontsize=10, fontfamily='monospace')
11
12 # Exemplo com raw string (r): para LaTeX puro
13 [Link](0, -0.75, r"Exemplo (r)__: $\sigma = {pi}$", fontsize=10, fontfamily='monospace')
14
15 [Link]()
10.8 Inserindo Comandos LATEX 115

[Link]
1 import numpy as np
2 import [Link] as plt
3 from [Link] import jn # Funcoes de Bessel
4
5 # Dados
6 x = [Link](0, 20, 500)
7 ordens = [0, 1, 2, 3, 4]
8 cores = ['navy', 'teal', 'orange', 'red', 'purple']
9
10 # Figura
11 [Link](figsize=(10, 8))
12
13 # Plot das Funcoes de Bessel de ordens 0 a 4
14 for n, cor in zip(ordens, cores):
15 y = jn(n, x)
16 [Link](x, y, label=rf"$J_{{{n}}}$", color=cor)
17
18 # Destaque para x = 4.9
19 x0 = 4.9
20 [Link](x0, color='gray', linestyle='--', linewidth=1)
21 [Link](x0, 0, marker=(4, 2, 0), color='black', markersize=10)
22 [Link](x0, -0.1, "4.9", fontsize=10,
23 bbox=dict(boxstyle="round,pad=0.3", facecolor='lightgray', edgecolor='black'))
24
25 # Anota valores especificos para cada curva em x = 4.9
26 for n, cor in zip(ordens, cores):
27 y_val = jn(n, x0)
28 [Link](x0, y_val, 'o', color=cor)
29 [Link](x0, y_val, f"{y_val:.5f}", color='white' if n in [0, 3, 4] else 'black',
30 fontsize=9, ha='center', va='center',
31 bbox=dict(boxstyle="round,pad=0.3", fc=cor, ec='black', lw=1))
32 [Link](x0 + 0.3, y_val, rf"${{J_{{{n}}}}}$", fontsize=11, va='center', color=cor)
33
34 # Rotulos dos eixos
35 [Link](r"$X$", fontsize=14)
36 [Link](r"$J_{\nu}(X)$", fontsize=14)
37
38 # Equacao diferencial no rodape
39 eq = r"$x^2 \frac{d^2y}{dx^2} + x \frac{dy}{dx} + (x^2 - \alpha^2)y = 0$"
40 [Link](10, -0.6, eq, fontsize=16, ha='center')
41
42 # Legenda
43 [Link](title="Funcoes de Bessel", fontsize=11, title_fontsize=12)
44
45 # Grade e layout
46 [Link](True)
47 plt.tight_layout()
48
49 [Link]()
116 Capítulo 10. Gráficos com Python

Figura 10.6: Duas imagens empilhadas em uma única coluna.

10.8 Inserindo Comandos LATEX 117

As Tabelas 10.2, 10.3 e 10.4 apresentam uma lista de símbolos especiais suportados.
Comando Comando Comando Comando
\alpha α \upsilon υ \supset ⊃ \lceil ⌈
\angle \phi \int \cdot
R
∠ ϕ ·
\ast ∗ \chi χ \rfloor ⌋ \neg ¬
\beta β \psi ψ \lfloor ⌊ \times ×
√
\gamma γ \omega ω \perp ⊥ \surd
\delta δ \heartsuit ♡ \wedge ∧ \varpi ϖ
\epsilon ϵ \zeta ζ \rceil ⌉ \rangle ⟩
\Gamma Γ \Theta Θ \vee ∨ \langle ⟨
\eta η \Lambda Λ \sim ∼ \leq ≤
\theta θ \Xi Ξ \copyright © \leq ≤
\vartheta ϑ \Pi Π \mid | \infty ∞
\iota ι \Sigma Σ \0 ∅ \clubsuit ♣
\kappa κ \Upsilon Υ \prime ′ \diamondsuit ♢
\lambda λ \Phi Φ \ldots ... \Delta ∆
\mu µ \Psi Ψ \nabla ∇ \spadesuit ♠
\nu ν \Omega Ω \o ø \leftrightarrow ↔
\xi ξ \forall ∀ \subset ⊂ \leftarrow ←
\pi π \exists ∃ \supseteq ⊇ \Leftarrow ⇐
\rho ρ \ni ∋ \oslash ⊘ \uparrow ↑
\sigma σ \cong ∼
= \wp ℘ \rightarrow →
\varsigma ς \approx ≈ \aleph ℵ \Rightarrow ⇒
\tau τ \Re ℜ \neq ̸ = \downarrow ↓
\equiv ≡ \oplus ⊕ \div ÷ \circ ◦
\Im ℑ \cup ∪ \bullet • \pm ±
\otimes ⊗ \subseteq ⊆ \bullet • \geq ≥
\cap ∩ \in ∈ \partial ∂ \propto ∝
\imath ı \ell ℓ \Re ℜ \Im ℑ
\aleph ℵ \wp ℘ \forall ∀ \exists ∃
\mho ℧ \partial ∂ \prime ′ \emptyset ∅
\nabla ∇ \infty ∞ \triangle △ \Box □
\Diamond ♢
√ \bot ⊥ \top ⊤ \angle ∠
\surd \heartsuit ♡ \clubsuit ♣ \diamondsuit ♢
\spadesuit ♠ \lnot ¬ \flat ♭ \natural ♮
.. ..
\dots ... \cdots ··· \vdots . \ddots .

Tabela 10.2: Comandos LATEX para diversos símbolos matemáticos

Comando Descrição Exemplo

^{ } Superscript text^{superscript}
_{ } Subscript text_{subscript}
\bf Negrito \bf text
\it Italico \it text
\sl Oblique font \sl text
\rm Fonte normal \rm text
\fontname{specifier} Nome da fonte \fontname{Courier} text
\fontsize{specifier} Tamanho da fonte \fontsize{15} text
\color{specifier} Cor da fonte \color{magenta} text
\color[rgb]{specifier} Cor personalizada da fonte \color[rgb]{0,0.5,0.5} text

Tabela 10.3: Comandos LATEX para diversos símbolos matemáticos

Comando Comando Comando

\sum \bigcup \bigvee
P S W

\prod \bigcap \bigwedge

Q T V

\int \bigsqcup \bigoplus

R F L

\oint \bigotimes \bigodot

H N J

Tabela 10.4: Símbolos matemáticos e seus comandos em LATEX.

 118 Capítulo 10. Gráficos com Python

10.9 Configurando Ambiente 3D

É possível criar uma figura tridimensional (3D) utilizando a biblioteca matplotlib, por
meio do módulo pyplot. Essa funcionalidade é bastante útil em aplicações que exigem
visualizações no espaço, como representação de superfícies, ou visualização de dados em três
dimensões. Embora o procedimento compartilhe diversos aspectos com a criação de gráficos
bidimensionais, alguns passos adicionais são necessários para habilitar a visualização em
3D.
Antes de começarmos a gerar gráficos tridimensionais, é necessário configurar um
ambiente adequado para esse tipo de visualização. O primeiro passo consiste na criação de
uma figura gráfica vazia e na definição de um sistema de eixos cartesianos tridimensional,
formado pelos eixos X, Y e Z.
Para isso, ao criar os eixos, devemos definir o parâmetro projection como "3d", o que
permitirá ao matplotlib interpretar a renderização em três dimensões. Esse processo é
essencial para qualquer tipo de gráfico 3D que desejamos desenvolver, como superfícies,
malhas, dispersões e outros tipos de representações visuais.
A seguir, apresentamos um exemplo simples no programa [Link]
de como configurar um ambiente básico para a visualização de gráficos em 3D utilizando o
matplotlib:

[Link]
1 import [Link] as plt
2 import numpy as np
3
4 fig = [Link]()
5 ax = [Link](projection="3d")
6 [Link]()

10.10 Construindo um Gráfico de Três Dimensões

A construção de gráficos tridimensionais na biblioteca matplotlib segue uma lógica
bastante semelhante à criação de gráficos bidimensionais. A principal diferença reside no
uso de métodos específicos para o espaço 3D, os quais geralmente apresentam a terminação
"3D" em seus nomes.
Como estamos lidando com um espaço tridimensional, é necessário fornecer três con-
juntos de coordenadas, representando as dimensões X, Y e Z, com o mesmo número
de elementos em cada vetor. Os demais parâmetros de estilização gráfica, apresentados
na Seção 10.7, como cor, tipo de linha, marcador e espessura, continuam válidos e são
aplicados da mesma forma que nos gráficos em duas dimensões.
Uma vez definidos os vetores de coordenadas, podemos representar trajetórias ou curvas
no espaço tridimensional por meio da função ax.plot3D(). Essa função é uma extensão
direta da tradicional plot(), utilizada em gráficos 2D, e conecta os pontos definidos pelos
vetores, formando uma linha contínua no espaço. Isso permite a visualização de funções
paramétricas, órbitas, caminhos ou qualquer sequência de pontos no espaço 3D. O programa
[Link] apresente um exemplo prático de como gerar uma curva 3D simples. A
Figura 10.7 ilustra a imagem produzida por esse programa.
 10.11 Gráfico de Dispersão 3D 119

[Link]
1 import [Link] as plt
2 import numpy as np
3
4 fig = [Link]()
5 ax = [Link](projection="3d")
6
7 vetor_x = [Link](0,25,100)
8 vetor_y = [Link](vetor_x)
9 vetor_z = [Link](vetor_x)
10
11 ax.plot3D(vetor_x, vetor_y, vetor_z, color = "g", label="Curva")
12 [Link]()
13 [Link]()

Figura 10.7: Imagem produzida pelo programa [Link].

10.11 Gráfico de Dispersão 3D

A função scatter3D() é utilizada para criar um gráfico de dispersão 3D, uma das formas
fundamentais de visualizar dados em três dimensões. Esse tipo de gráfico permite represen-
tar graficamente um conjunto de pontos distribuídos no espaço cartesiano tridimensional,
utilizando coordenadas ao longo dos eixos X, Y e Z. Cada ponto representa uma observação
individual, sendo posicionado com base nos valores de três variáveis numéricas.
Esse tipo de gráfico é amplamente utilizado em áreas como estatística e ciência de dados,
pois facilita a identificação de padrões, tendências e agrupamentos (clusters) nos dados.
Além disso, é possível personalizar a visualização por meio do uso de cores, tamanhos e
formas dos marcadores.
A seguir, o exemplo [Link] ilustra como utilizar a função scatter3D()
120 Capítulo 10. Gráficos com Python

para gerar um gráfico de dispersão tridimensional.

[Link]
1 import [Link] as plt
2 import numpy as np
3
4 fig = [Link]()
5 ax = [Link](projection="3d")
6
7 vetor_x = [Link](0,25,125)
8 vetor_y = [Link](vetor_x)
9 vetor_z = [Link](vetor_x)
10
11 ax.scatter3D(vetor_x, vetor_y, vetor_z)
12 [Link]()
 10.12 Plotagem de Superfície 3D 121

10.12 Plotagem de Superfície 3D

A plotagem de uma superfície 3D é uma representação gráfica tridimensional que descreve
a relação funcional entre duas variáveis independentes, X e Y , e uma variável dependente
Z, que pode ser interpretada como a altura da superfície em cada ponto da grade. Esse
tipo de gráfico é amplamente utilizado em matemática, física, estatística e aprendizado de
máquina para visualizar distribuições de dados e funções complexas.
Para criar gráficos de superfícies tridimensionais no matplotlib, utilizamos a função
plot_surface() do módulo Axes3D. A sintaxe básica é: plot_surface(X, Y, Z), onde
X e Y são matrizes 2D que definem a grade de pontos no plano cartesiano, e Z é uma matriz
que representa os valores de altura (ou profundidade) da superfície em cada ponto dessa
grade. Para gerar as matrizes X e Y, utilizamos a função [Link](), que constrói uma
malha bidimensional combinando dois vetores unidimensionais, um para os valores de x e
outro para os valores de y. O resultado são duas matrizes que contêm todas as combinações
possíveis de pares (x, y) na grade do plano XY . A Figura 10.8 ilustra o processo de criação
dessas matrizes e como elas são utilizadas para calcular os valores da superfície. O código
do programa [Link] apresenta um gráfico de superfície tridimensional.

1 2 3 4 Vetor de Entrada X
5
Vetor de Entrada Y

m5,1 m5,2 m5,3 m5,4

1 2 3 4
5
6

6 m6,1 m6,2 m6,3 m6,4

7

8 7 m7,1 m7,2 m7,3 m7,4

8 m8,1 m8,2 m8,3 m8,4

5 5 5 5 1 2 3 4

6 6 6 6 1 2 3 4

7 7 7 7 1 2 3 4

8 8 8 8 1 2 3 4

Matriz Y (ı́ndices das linhas) Matriz X (ı́ndices das colunas)

Figura 10.8: Geração das matrizes X e Y com a função [Link](), a partir de vetores
unidimensionais de entrada. A matriz X contém, em cada linha, cópias do vetor de entrada
x, enquanto a matriz Y contém, em cada coluna, cópias do vetor de entrada y. Essas
matrizes representam a malha de coordenadas no plano XY .
122 Capítulo 10. Gráficos com Python

[Link]
1 import [Link] as plt
2 import numpy as np
3
4 fig = [Link]()
5 ax = [Link](projection="3d")
6
7 # Make data.
8 vetor_X = [Link](-5, 5, 0.25)
9 vetor_Y = [Link](-5, 5, 0.25)
10 [matriz_X, matriz_Y] = [Link](vetor_X, vetor_Y)
11 R = [Link](matriz_X**2 + matriz_Y**2)
12 matriz_Z = [Link](R)
13 ax.plot_surface(matriz_X, matriz_Y, matriz_Z, cmap="jet")
14
15 [Link]()

p 
Figura 10.9: Gráfico de superfície da função z = sin x2 + y 2 ,
gerado pela função plot_surface() e mapa de cores "jet".

A função plot_surface() aceita diversos parâmetros opcionais, entre eles o parâmetro

cmap, que permite definir o mapa de cores aplicado à superfície plotada. Esse parâmetro é
utilizado para associar uma escala de cores aos valores da matriz Z, facilitando a visualização
das variações de altura na superfície.
No programa [Link], foi utilizado o argumento cmap="jet", que cor-
responde a uma paleta de cores tradicional composta por tons que vão do azul ao vermelho,
passando por verde e amarelo. A Tabela 10.5, apresenta alguns exemplos de paletas de
cores disponíveis, que podem ser utilizadas com a função plot_surface.
10.12 Plotagem de Superfície 3D 123

Nome Descrição Amostra

viridis Perceptualmente uniforme e acessível
plasma Tons quentes do roxo ao amarelo
inferno Forte contraste, ideal para dados científicos
magma Escuro e suave, do preto ao bege
cividis Daltônico-friendly, boa linearidade
jet Colorido, mas não uniforme
coolwarm Ideal para variações centradas em zero
terrain Simula elevação de terrenos naturais
ocean Tons de azul ondulados, geociências
rainbow Colorido clássico, não uniforme

Tabela 10.5: Principais mapas de cores do Matplotlib (cmap).

.
 124 Capítulo 10. Gráficos com Python

Folha de Exercício 19: [Solução da Folha de Exercício 19]

1. Curvas helicoidais e espirais aparecem com frequência em 3. Construa um gráfico de superfície para a função:
aplicações de engenharia, física e visualização científica. Um
z = sin(x2 + y 2 )
exemplo clássico é a trajetória de partículas carregadas em
campos magnéticos. Implemente um programa em Python Utilize a função [Link]() e a função plot_surface()
que simule a trajetória de uma espiral tridimensional descrita para gerar a visualização.
pelas equações paramétricas 10.1:
4. A equação de uma hélice é dada por:
x(t) = t cos(t), y(t) = t sin(t), z(t) = t (10.1)
x(t) = r cos(t)
O programa deve solicitar ao usuário: (i) o valor inicial de
y(t) = r sin(t)
t; (ii) o valor final de t; e (iii) o número de pontos a serem
usados na simulação. Por fim, plote a trajetória da partícula z(t) = at
em um gráfico tridimensional conectando os pontos com
Com r e a fornecidos pelo usuário, plote uma hélice 3D
uma linha contínua.
usando ‘matplotlib‘.
2. Dada a função:
5. A equação de uma espiral logarítmica é dada por:
x = sin(t), y = cos(2t), z = sin(3t)
x(t) = eat cos(t)
Crie um programa que plote a curva em 3D no intervalo de
y(t) = eat sin(t)
tempo informado pelo usuário.
Com a fornecido pelo usuário, plote a espiral.
 10.12 Plotagem de Superfície 3D 125

Folha de Exercício 20: [Solução da Folha de Exercício 20]

1. A posição de uma partícula em movimento em função do 9. Simule a propagação de uma onda bidimensional estacioná-
tempo é dada pela Equação 10.2. Crie um programa capaz ria:
de calcular a posição da partícula para um dado intervalo
de tempo t. O programa deve solicitar ao usuário (usando o z(x, y, t) = sin(x) cos(y) cos(t)
comando input) o intervalo de tempo e o tamanho do vetor.
Faça o gráfico de Dispersão 3D e o seu Traçando de Linha. Permita que o usuário selecione um valor de t e gere a
Em seguida, o programa deve calcular os vetores x, y e z superfície correspondente.
usando a Equação 10.2:
10. Gere a superfície de uma função onda modulada:
x = (4 − 0.1t)sen(0.8t) 2
+y 2 )
y = (4 − 0.1t)cos(0.8t) z(x, y) = e−0.1(x sin(5x) cos(5y)
3/2
z = 0.4t (10.2) Faça o gráfico 3D para x, y ∈ [−4, 4] com boa resolução de
pontos.
2. Faça um gráfico de superfície de z = sin(x) ∗ sin(y), com
x, y ∈ [−2, 2]. 11. Calcule a matriz de diferença absoluta entre duas matrizes
F e G de ordem n × n, e utilize essa matriz para gerar
3. Faça um gráfico de superfície de z = sin(x + sin(y)), com uma visualização gráfica dos erros por meio de um heatmap
x, y ∈ [−10, 10]. (mapa de calor). A matriz de diferença absoluta D[i, j] é
obtida conforme a Equação 10.3:
4. Faça um gráfico de superfície de z = (x2 ∗ y)/(x2 + y 2 ).
D[i, j] = |F [i, j] − G[i, j]| (10.3)
5. Considere uma matriz de altura H(x, y) = sin(x) sin(y) em
uma malha 2D. Gere o gráfico de contorno (níveis de alti- Após o cálculo da matriz D, utilize o seguinte comando para
tude) com rótulos de nível usando contourf e clabel. criar um mapa de calor: [Link](D, cmap="viridis")
e [Link](label="Intensidade").
6. Modele a dissipação de calor radial com:
2
+y 2 )
12. Em um universo paralelo bidimensional, considere a tra-
T (x, y) = T0 e−α(x jetória aleatória de um bêbado saindo do bar Cantinho
Peça ao usuário T0 e α e gere um gráfico com imshow e Universitário em direção à sua casa. A localização da casa
colorbar. será representada pelas coordenadas cartesianas de um re-
tângulo, informadas pelo usuário. O deslocamento aleatório
7. Plote a função: do bêbado a cada passo é descrito pela seguinte equação:
p
sin( x2 + y 2 ) xt+1 = xt + sx
f (x, y) = p
x2 + y 2 yt+1 = yt + sy
Utilize uma visualização 3D com plot_surface.
onde sx e sy são números aleatórios tais que −1 ≤ sx , sy ≤ 1.
Além disso, o usuário deve informar um segundo parâmetro:
8. Construa a trajetória de uma partícula sujeita a força cen-
o número máximo de passos que o bêbado pode realizar
trípeta:
antes de desmaiar e dormir na rua. Escreva um programa
x(t) = R cos(ωt) que simule esse processo e, ao final, informe se o bêbado
y(t) = R sin(ωt) conseguiu chegar em casa. Para representar graficamente a
z(t) = ht trajetória, produza dois gráficos:

Permita ajustar os parâmetros R, ω e h via input.

• Um gráfico de linha, que mostra o caminho percorrido;
• Um gráfico de dispersão, destacando a posição inicial
(bar), a posição final do bêbado e a posição da casa.
 126 Capítulo 10. Gráficos com Python

Folha de Exercício 21: [Solução da Folha de Exercício 21]

21.
II
Parte Dois: Cálculo Numérico

11 Erros Numéricos . . . . . . . . . . 129

12 Raizes de uma Função . . . . . . . . 141
13 Otimização . . . . . . . . . . . . . 159
14 Interpolação . . . . . . . . . . . . 173
15 Sistemas de Equações Lineares . . . . 191
16 Integração Numérica . . . . . . . . 199
17 Derivação Numérica . . . . . . . . . 213
Bibliography . . . . . . . . . . . . 215
18 Solução . . . . . . . . . . . . . . 221
 11. Erros Numéricos

11.1 Fundamentos
Arredondamentos e erros são aspectos inevitáveis e, ao mesmo tempo, essenciais na compu-
tação numérica. Infelizmente, nem todos os números podem ser representados de forma
exata pelos computadores, o que dá origem aos chamados erros de arredondamento. A
resolução de problemas numéricos com o uso de computadores está naturalmente sujeita a
esse tipo de erro.
Esses erros podem surgir de diferentes formas, como resultado de limitações na represen-
tação binária de números decimais, truncamentos, ou da própria forma como as operações
aritméticas são realizadas. Para compreender adequadamente os efeitos e a propagação
desses erros, é necessário estudar algumas definições fundamentais, tais como:

• O critério de arredondamento adotado pelo sistema;

• Erro absoluto: mede a diferença entre o valor numérico aproximado e o valor exato;
• Erro relativo: expressa o erro absoluto em proporção ao valor verdadeiro.
Entender essas definições é essencial para avaliar a confiabilidade de soluções numéricas e
controlar o impacto dos erros ao longo dos cálculos computacionais.

11.2 Representação de Ponto Flutuante

Embora o conjunto dos números reais R seja definido como um conjunto infinito e contínuo,
sua representação em computadores é limitada. Em ambientes computacionais, restrições
físicas como capacidade finita de memória e largura de palavra impõem a necessidade
de representar números reais por meio de aproximações discretas. Essa aproximação é
realizada por um subconjunto finito de R conhecido como conjunto dos números de ponto
flutuante, denotado por F.
Diferentemente de R, que contém infinitos elementos entre quaisquer dois pontos, o
conjunto F é finito, composto por valores numericamente bem definidos, espaçados entre si e
determinados por padrões como o IEEE 754 [6]. Isso implica que operações aritméticas em
F podem sofrer perda de precisão, cancelamento numérico e não obedecer às propriedades
usuais da álgebra.
 130 Capítulo 11. Erros Numéricos

Para que um número possa ser representado na memória do computador, ele deve ser
convertido para a base binária, uma vez que os sistemas digitais operam com bits, que
assumem apenas os valores 0 e 1. No entanto, nem todos os números decimais possuem
uma representação binária exata e finita. Isso ocorre porque o sistema binário é baseado
em potências de dois, enquanto muitos números decimais requerem frações que não podem
ser expressas com precisão nesse formato.
Por exemplo, valores aparentemente simples como 0.1 ou 0.3 resultam em representações
binárias infinitas e periódicas, de maneira análoga a como a fração 1/3 corresponde a
0.33333 . . . no sistema decimal. Como os computadores utilizam um número limitado de bits
para armazenar essas representações, é necessário realizar um corte ou um arredondamento,
o que inevitavelmente introduz pequenas imprecisões. Essas aproximações são conhecidas
como erros de arredondamento. Por exemplo. A representação binários do número
decimal 0.1 será:
0.110 = 0.0001100110011001100 . . .2 (11.1)
Sendo 0.0001100110011001100 com uma dízima periódica 0011 que se repete infini-
tamente. Portanto, por conta da dízima periódica, o valor não pode ser representado
precisamente (não existe memória infinita para representar uma dízima que se repete
infinitamente). Assim, quando convertemos 0.00011001100110011012 novamente para a
base 10, temos:
0.00011001100110011012 ≈ 0.1000000000000000210 (11.2)
Ou seja, um erro da ordem de 0.00000000000000002 (2 × 10−17 ) foi introduzido. Esse
fenômeno é inerente à aritmética de ponto flutuante e pode se acumular em operações
sucessivas. Por isso, deve-se evitar comparar diretamente dois números float quanto à
igualdade, pois o resultado pode ser logicamente incorreto, mesmo que os valores aparentem
ser iguais. Para ilustrar esse comportamento, observe o seguinte programa:
[Link]
1 x = 1.2 - 1.0
2 print(x)

CotoNet@linux:
0.19999999999999996

11.3 O Padrão IEEE 745

Em 1985, o IEEE (Instituto de Engenheiros Elétricos e Eletrônicos) publicou um relatório
chamado IEEE Standard for Binary Floating-Point Arithmetic (IEEE 754-1985 ). Este
documento estabeleceu as bases para a representação e manipulação de números reais em
ponto flutuante por sistemas computacionais. Uma versão atualizada foi lançada em 2019,
denominada IEEE 754-2019 [6], com extensões para diferentes bases e formatos.
O padrão define representações para números em ponto flutuante com precisão simples
(32 bits), dupla (64 bits) e estendida, além de formatos decimais e regras para arredonda-
mento, tratamento de exceções e operações especiais como NaN (Not a Number) e infinitos.
Essas especificações são amplamente adotadas por arquiteturas modernas computadores.
Na precisão dupla (64 bits), cada número real é representado utilizando a seguinte
estrutura:
 11.4 Computadores e arquiteturas com precisão maior que 64 bits 131

• 1 bit de sinal (s): indica o sinal do número (0 para positivo, 1 para negativo);
• 11 bits de expoente (c): codifica o expoente com um viés (bias);
• 52 bits de fração (f ): representa a mantissa, ou parte fracionária da significando.
A representação de números reais no formato de ponto flutuante de 64 bits (precisão
dupla) permite armazenar uma ampla faixa de valores, aproximadamente entre:

±4.940656 × 10−324 até ± 1.797693 × 10308 (11.3)

Além disso, essa representação garante uma precisão decimal de aproximadamente 15 a

17 dígitos significativos, permitindo que operações matemáticas com ponto flutuante sejam
realizadas com alto grau de exatidão.
O código a seguir ilustra de maneira prática as limitações da representação de ponto
flutuante em 64 bits, demonstrando o que ocorre quando um número muito grande ultrapassa
o limite máximo de representação:

[Link]
1 x = 1e308 # Um numero muitoooo grande!!
2 print("x =", x)
3
4 y = x * 2 # Multiplicando *2 para tentar causar o overflow
5 print("y =", y)

CotoNet@linux:
x = 1e+308
y = inf

Neste exemplo, a variável x é inicializada com o valor 1 × 10308 , que está próximo
do limite superior de representação para um número de ponto flutuante de 64 bits. Ao
multiplicar x por 10, o resultado esperado matematicamente seria 1 × 10309 . No entanto,
esse valor excede o maior número representável no formato float64 (double), e o Python,
ao seguir o padrão IEEE 754, representa o resultado como inf (infinito). Assim, a linha
print("y =", y) exibirá: y = inf.

11.4 Computadores e arquiteturas com precisão maior que 64 bits

Embora a precisão dupla (64 bits) seja o padrão em muitas arquiteturas modernas, existem
sistemas e processadores que oferecem precisão maior para operações em ponto flutuante.
Alguns exemplos incluem:
• Precisão estendida de 80 bits (Extended Precision): disponível em processado-
res da família x86, como Intel e AMD, implementada no co-processador matemático
(unidade de ponto flutuante - FPU). Esse formato permite aproximadamente 19
dígitos decimais de precisão.
• Precisão quádrupla de 128 bits (Quadruple Precision): definida no padrão
IEEE 754-2008, o formato binary128 oferece 34 dígitos decimais de precisão. Dispo-
nível em algumas arquiteturas, como IBM Power, SPARC e implementações específicas
no RISC-V. Além disso, compiladores como o GCC e biblioteca como quadmath.h
permite o uso dessa precisão em software.
 132 Capítulo 11. Erros Numéricos

• Softwares e bibliotecas de precisão arbitrária: ferramentas como Mathematica,

Maple, o Symbolic Toolbox do Matlab ou a biblioteca mpmath do Python permitem
realizar cálculos com precisão muito além de 64 ou 128 bits.

[Link]
1 from mpmath import mp
2
3 # Definindo a precisao para 128 bits (34 digitos decimais)
4 [Link] = 34 # dps = decimal places
5
6 # Criando numeros de alta precisao
7 a = [Link]("1.2345678901234567890123456789012345")
8 b = [Link]("9.8765432109876543210987654321098765")
9
10 # Operacoes matematicas
11 soma = a + b
12 produto = a * b
13 raiz = [Link](a)
14
15 # Exibindo resultados
16 print(f"a = {a}")
17 print(f"b = {b}")
18 print(f"Soma = {soma}")
19 print(f"Produto = {produto}")
20 print(f"Raiz = {raiz}")

CotoNet@linux:
a = 1.234567890123456789012345678901235
b = 9.876543210987654321098765432109877
Soma = 11.11111110111111111011111111101111
Produto = 12.19326311370217952261850327338668
Raiz = 1.111111106111111099361111058186111

11.5 Tipos de Arredondamentos

Chamamos de arredondamento o processo de representar um número com menos algarismos
(k) do que ele originalmente possui. Podemos arredondar esse número sempre de duas
maneiras: (i) Truncamento ou por (ii) Aproximação.
• Truncamento: os algarismos além da posição k são simplesmente ignorados, sem
considerar seu valor.
• Aproximação (ou arredondamento propriamente dito): os algarismos descartados
influenciam o valor do último dígito mantido, aumentando-o quando necessário.
A seguir, temos uma função simples em Python que realiza a operação de truncamento
decimal, mantendo apenas os k primeiros algarismos após a vírgula:

[Link]
1 def trunca_float(x,k):
2 sp = str(x).split(".")
3 return float(sp[0] + "." + (sp[1][:k]))

No arredondamento por aproximação, o valor do dígito imediatamente após a posição

 11.6 Tipos de Erros 133

desejada (ou seja, o dn+1 ) determina se o último dígito mantido dn permanece o mesmo
ou é incrementado em uma unidade. Se dn+1 estiver entre 0 e 4, mantemos dn inalterado;
caso dn+1 esteja entre 5 e 9, adicionamos uma unidade a dn .Resumidamente, para se obter
uma aproximação com n algarismos, aplicamos a seguinte regra:


 dn se 0 ≤ dn+1 ≤ 4

dn = (11.4)
 dn + 1 se 5 ≤ dn+1 ≤ 9


No Python, a função round() realiza o arredondamento por aproximação. O segundo

parâmetro dessa função indica o número de casas decimais desejadas no resultado. Veja o
exemplo a seguir:

[Link]
1 a = 3.145623
2 print(round(a,2))
3 print(round(a,3))

11.6 Tipos de Erros

Vamos considerar, de forma fundamental, dois tipos de erros muito importantes na análise
numérica: (i) o Erro Absoluto (EA) e (ii) o Erro Relativo (ER). Essas definições são
essenciais para o estudo da tolerância na aplicação de métodos numéricos, assim como para
a análise de sua convergência.
O Erro Absoluto (EA) é definido como:

EA(x) = |x − x̄| (11.5)

onde x é o valor exato e x̄ a aproximação para o mesmo. O erro absoluto, como

a definição sugere, mede a diferença absoluta entre o valor real e o valor aproximado,
fornecendo uma ideia do quanto os resultados obtidos se afastam do valor verdadeiro.
Já o Erro Relativo (ER) é dado por:

|x − x̄| EA(x)
ER(x) = = (11.6)
|x| |x|

O erro relativo, por ser uma razão entre o erro absoluto e o valor real, é uma medida
adimensional. Ele fornece uma noção da magnitude do erro em relação ao tamanho do
valor verdadeiro, sendo, portanto, uma métrica proporcional que facilita a comparação de
erros em diferentes escalas.
 134 Capítulo 11. Erros Numéricos

Exemplo: 1
Seja x = 0.666888, Defina: (i) x̄1 : o valor obtido ao truncar x com 3 casas decimais e (ii) x̄2 : o
valor obtido ao arredondar x com 3 casas decimais. Calcule o erro relativo de x̄1 e x̄2 em relação
ao valor original x. Qual o arredondamento aproxima melhor o valor de x ?
Solução:
|x − x¯1 | 0.666888 − 0.666
ER(x̄1 ) = = = 0.0013315579227696 (11.7)
|x| 0.666888

|x − x¯2 | 0.666888 − 0.667

ER(x̄2 ) = = = 0.0001679442425115 (11.8)
|x| 0.666888
Isto leva a conclusão que x¯2 aproxima melhor o valor de x do que x¯1 pois está mais próximo de x.

11.7 A Importância de Considerar Erros Numéricos

É verdade que os erros de arredondamento são
geralmente muito pequenos. No entanto, quando
acumulados ao longo de diversas iterações de cálcu-
los, esses erros podem crescer e ter consequências
catastróficas. Um exemplo notável é a explosão do
foguete Ariane 5, em 4 de junho de 1996 [8].
O acidente ocorreu apenas 39 segundos após o
lançamento, devido a um erro de conversão numé-
rica no software de controle de velocidade. Esse
software, herdado do Ariane 4, não possuía prote-
ção contra overflow. A falha aconteceu quando um
valor em ponto flutuante de 64 bits foi convertido
para um inteiro de 16 bits, ultrapassando o limite
de representação, o que resultou na interrupção
do sistema inercial de referência (SRI) e na perda
de controle do foguete. O incidente causou um
prejuízo superior a 7.5 milhões de euros para a Figura 11.1: Explosão foquete
Agência Espacial Europeia. Ariane 5 devido a um overflow.
Embora esse exemplo seja extremo, situações
menos dramáticas também podem ocorrer. Considere, por exemplo, a sequência definida
na Equação 11.9.

r q
n−1/2
z2 = 2, zn+1 = 2 1− 1 − (41−n · zn2 ), n = 2, 3, . . . (11.9)

Essa sequência converge para π quando n tende ao infinito. Apesar de sua eficiência
teórica, a implementação numérica dessa sequência em computadores apresenta desafios
significativos de estabilidade numérica.
Vamos definir α = (41−n · zn2 ). Assim, podemos reescrever zn+1 como:
q √
zn+1 = 2n−1/2 1 − 1 − α
A instabilidade principal ocorre devido à presença de expressões do tipo 1 − α. À
medida que n aumenta, o α tende rapidamente a zero, o que faz com que o argumento da
11.7 A Importância de Considerar Erros Numéricos 135

raiz interna se aproxime de 1. Isso leva a um problema conhecido como cancelamento

catastrófico: a subtração de dois números muito próximos entre si resulta em perda
significativa de dígitos significativos, comprometendo a precisão do resultado. Essa perda
é então amplificada ao ser passada para a segunda raiz quadrada e multiplicada por um
1
fator exponencialmente crescente 2n− 2 , o que pode eventualmente fazer com que o valor
de zn cresça rapidamente de forma errada.

A Figura ?? apresenta o Erro Absoluto e Relativo ao longo das iterações da sequência

definida na Equação 11.9. Observa-se que o erro relativo entre zn e π diminui nas primeiras
16 iterações, mas, a partir desse ponto, começa a aumentar devido à acumulação de erros de
arredondamento, especialmente em ambientes de precisão limitada (como ponto flutuante
de 64 bits).

[Link]
1 import math
2
3 max_int = 30
4 z = 2.0
5 alpha=1
6 for n in range(2, max_int):
7 erro_rel = abs([Link])/([Link])
8 print("n: %2.d, alpha: %.14f, z: %.8f, erro: %.14f" %(n,(alpha),z,erro_rel))
9 fator = 2.0**(n - 0.5)
10 alpha = 4.0**(1-n)*(z**2)
11 raiz = [Link](1.0-alpha)
12 z = fator * [Link](1.0-raiz)

CotoNet@linux:
n: 2, alpha: 1.00000000000000, z: 2.00000000, erro: 0.36338022763242
n: 3, alpha: 1.00000000000000, z: 2.82842712, erro: 0.09968368384289
n: 4, alpha: 0.50000000000000, z: 3.06146746, erro: 0.02550464159557
n: 5, alpha: 0.14644660940673, z: 3.12144515, erro: 0.00641314885579
n: 6, alpha: 0.03806023374436, z: 3.13654849, erro: 0.00160560696438
n: 7, alpha: 0.00960735979838, z: 3.14033116, erro: 0.00040154685033
n: 8, alpha: 0.00240763666390, z: 3.14127725, erro: 0.00010039578386
...
n: 23, alpha: 0.00000000000224, z: 3.14167427, erro: 0.00002597772562
n: 24, alpha: 0.00000000000056, z: 3.14182968, erro: 0.00007544845101
n: 25, alpha: 0.00000000000014, z: 3.14245127, erro: 0.00027330688572
n: 26, alpha: 0.00000000000004, z: 3.14245127, erro: 0.00027330688572
n: 27, alpha: 0.00000000000001, z: 3.16227766, erro: 0.00658424208974
n: 28, alpha: 0.00000000000000, z: 3.16227766, erro: 0.00658424208974
n: 29, alpha: 0.00000000000000, z: 3.46410162, erro: 0.10265779084358
136 Capítulo 11. Erros Numéricos

Erro ao longo das iterações

100

10−2

10−4
Erro

10−6

10−8

Erro Absoluto
Erro Relativo
10−10
2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32

n
 11.7 A Importância de Considerar Erros Numéricos 137

Laboratório Computacional: 1
O Sistema de Lorenz e o Caos Numérico
Em 1961, o meteorologista Edward Lorenz estava simulando modelos climáticos em
um computador Royal McBee LGP-30 quando, ao tentar repetir uma simulação para
economizar tempo, decidiu inserir os dados de uma execução anterior como condição
inicial; embora o computador processasse internamente os dados com 6 casas decimais
(0.506127), a impressão que Lorenz tinha em mãos exibia apenas 3 casas (0.506). Ao
assumir que essa diferença de menos de 0.1% seria irrelevante e retornar de uma pausa
para o café, Lorenz percebeu que as duas previsões haviam divergido drasticamente,
uma indicando tempo firme e a outra uma tempestade severa, demonstrando que,
em sistemas não lineares, pequenos erros de arredondamento ou truncamento não
permanecem pequenos, mas crescem exponencialmente, dando origem ao que hoje
conhecemos como Teoria do Caos.
O Sistema de Lorenz é um modelo matemático composto por três equações diferenciais
ordinárias (EDOs) não lineares e acopladas, proposto em 1963 para descrever de forma
simplificada a convecção atmosférica. Este sistema é o paradigma fundamental da
Teoria do Caos, demonstrando como leis determinísticas podem gerar comportamentos
imprevisíveis. O modelo descreve a evolução temporal de três variáveis (x, y, z):
dx dy dz
= σ(y − x), = x(ρ − z) − y, = xy − βz
dt dt dt
A propriedade mais notável deste sistema é a sua dependência sensível às condições iniciais. Incertezas infinitesimais,
como erros de arredondamento inerentes à representação de ponto flutuante (10−16 ) ou pequenas variações nos dados de
entrada, são amplificadas exponencialmente ao longo do tempo. Para ilustrar, considere duas simulações idênticas diferenciadas
apenas por um erro de 0.0001 em uma das variáveis. Embora as trajetórias permaneçam próximas por um curto intervalo, elas
divergem de forma irremediável após um tempo crítico. O sistema de Lorenz serve como um lembrete de que o determinismo
das equações não garante a previsibilidade do resultado computacional. O sistema é determinístico (as equações definem
exatamente o próximo passo), mas é imprevisível a longo prazo, pois precisaríamos de precisão infinita nas condições iniciais
para eliminar o erro.
Laboratório Computacional
Como o Sistema de Lorenz é dinâmico, o estado das variáveis (x, y, z) muda continuamente. Para simular esse comportamento
no computador, dividimos o tempo em pequenos intervalos ∆t = 0.01.
A partir de um ponto conhecido (xn , yn , zn ) no instante n, os valores no próximo instante n + 1 são calculados somando-se a
variação acumulada naquele pequeno intervalo. Utilize as seguintes equações de atualização:

xn+1 = xn + [σ(yn − xn )] · ∆t yn+1 = yn + [xn (ρ − zn ) − yn ] · ∆t zn+1 = zn + [xn yn − βzn ] · ∆t

| {z } | {z } | {z }
Variação em x Variação em y Variação em z

Crie uma função em Python capaz de simular o sistema por 5000 iterações. Considere os parâmetros constantes: σ = 10,
ρ = 28 e β = 8/3. Em seguida, realize duas simulações numéricas distintas, A e B, que utilizam os mesmos parâmetros de
Lorenz, mas partem de condições iniciais ligeiramente diferentes:
• Configuração A (Referência): P0 ′= (1.0, 1.0, 1.0)
• Configuração B (Perturbada): P0 = (1.0 + ϵ, 1.0, 1.0), com ϵ = 10−3
Com base nas duas trajetórias A e B, calcule a distância euclidiana entre as trajetórias em cada instante t usando a equação:
p
E(t) = (xA − xB )2 + (yA − yB )2 + (zA − zB )2

Questões para Discussão:

1. Crescimento do Erro: Plote o gráfico de (E(t)) em função do tempo.
2. Horizonte de Predição: Identifique em que instante de tempo o erro E(t) atinge a mesma ordem de grandeza das
variáveis do sistema (≈ 20). O que isso significa para a capacidade de previsão do modelo?
3. Influência de ∆t: Se reduzirmos ∆t pela metade, o erro final entre as duas configurações desaparecerá? Justifique
sua resposta com base na natureza do sistema.
 138 Capítulo 11. Erros Numéricos

Folha de Exercício 22: [Solução da Folha de Exercício 22]

1. Escreva um programa para calcular uma aproximação do 6. A função cosseno hiperbólico pode ser calculada por meio
valor de π utilizando a seguinte série infinita, representada de sua expansão em série infinita, conforme representado
na Equação 11.10. O programa deve solicitar ao usuário o na Equação 11.15. Desenvolva um programa que solicite ao
número de iterações desejadas. Para cada iteração, calcule usuário o número de iterações desejado. Para cada iteração,
o erro relativo em relação ao valor real de π. Ao final, gere calcule o erro relativo em relação ao valor real de cosh(x).
um gráfico ilustrando a evolução do erro relativo ao longo Ao final, gere um gráfico que mostre a evolução do erro
das iterações. relativo ao longo das iterações.
∞ ∞
Y (2n)2 x2n
π=2 (11.10)
X
cosh(x) = (11.15)
(2n − 1)(2n + 1) (2n)!
n=1 n=0

2. A expansão em série de Taylor da função f (x) = ex é repre- 7. A série BBP (Bailey–Borwein–Plouffe) é uma fórmula para
sentada pela Equação 11.11. Desenvolva um programa em calcular π diretamente em base hexadecimal (base 16), apre-
Python para calcular a aproximação de ex com base nessa sentada na Equação 11.16. Desenvolva um programa que
série, interrompendo as iterações quando for atingido um utilize essa série para calcular uma aproximação de π, utili-
erro absoluto mínimo pré-definido. Para melhor visualização zando um número de iterações fornecido pelo usuário. Em
do desempenho da aproximação, gere um gráfico que mostre cada iteração, calcule o erro relativo e, ao final, gere um grá-
a evolução do erro absoluto a cada iteração. fico que mostre a evolução desse erro ao longo das iterações.
∞
X xn ∞
ex = (11.11) X 1

4 2 1 1

n! π= − − − (11.16)
n=0 16n 8n + 1 8n + 4 8n + 5 8n + 6
n=0
3. A função seno pode ser aproximada por meio de sua expan-
são em série de Taylor, conforme mostrado na Equação 11.12. 8. A série infinita apresentada na Equação 11.17 converge para
4
Desenvolva um programa em Python para calcular essa apro- o valor λ = π90 quando n → ∞. Escreva um programa em
ximação até que um erro absoluto mínimo seja atingido. O Python para calcular a aproximação de f (n) com base em
programa deve solicitar ao usuário o valor de x e o erro um número de iterações fornecido pelo usuário. Para cada
absoluto mínimo desejado. Ao final, gere um gráfico que iteração, calcule o erro relativo em relação ao valor exato de
mostre a evolução do erro relativo ao longo das iterações. λ. Ao final, gere um gráfico que mostre a evolução do erro
∞ relativo ao longo das iterações.
X (−1)n x2n+1
sen(x) = (11.12) ∞
(2n + 1)! X 1
n=0 f (n) = (11.17)
n4
n=1
4. A função cosseno pode ser aproximada por meio de sua
expansão em série de Taylor, conforme expressa na Equa-
9. Escreva um programa em Python para estimar o valor de
ção 11.13. Desenvolva um programa em Python para calcu-
π utilizando o método de Monte Carlo, seguindo os passos
lar essa aproximação até que um erro absoluto mínimo seja
descritos abaixo:
atingido. O programa deve solicitar ao usuário o valor de
x e o valor desejado para o erro absoluto mínimo. Ao final, • O programa deve solicitar o número de pontos n a
serem gerados.
gere um gráfico que mostre a evolução do erro relativo ao
longo das iterações. • Utilize a função rand() para gerar n pares de pon-
tos aleatórios {xk , yk }, com k = 1, . . . , n, onde xk e yk
∞
X (−1)n x2n pertencem ao intervalo [0, 1].
cos(x) = (11.13) • Para cada par, calcule zk = x2k + yk2 .
(2n)!
n=0 • Conte o número de pontos m que satisfazem a condição
zk ≤ 1, ou seja, que estão dentro do quarto de círculo
5. Escreva um programa para calcular a função seno hiperbó- de raio 1.
lico, cuja expressão pode ser representada pela série infinita
mostrada na Equação 11.14. O programa deve solicitar ao
• Estime o valor de π usando a fórmula:
usuário o número de iterações desejado. Para cada iteração, 4m
πn =
calcule o erro relativo em relação ao valor real de sinh(x). n
Ao final, gere um gráfico que ilustre a evolução do erro
Ao final, o programa deve exibir na tela: (i) O número
relativo ao longo das iterações.
total de pontos gerados n; (ii) O número de pontos m que
∞
X x2n+1 satisfazem zk ≤ 1; (iii) O valor estimado de π com base
sinh(x) = (11.14) no método e (iv) Faça um gráfico de dispersão, no qual os
(2n + 1)!
n=0 pontos que satisfazem zk ≤ 1 devem ser plotados em azul, e
os que não satisfazem essa condição, em vermelho
 11.7 A Importância de Considerar Erros Numéricos 139

Folha de Exercício 23: [Solução da Folha de Exercício 23]

1. A constante de Euler-Mascheroni, denotada por γ, aparece 6. A função ln(1 + x) pode ser aproximada pela série de Taylor
em diversas áreas da matemática, como análise e teoria dos apresentada na Equação 11.23. Desenvolva um programa
números. Seu valor aproximado é γ ≈ 0.577215664901532 e para calcular essa aproximação, solicitando ao usuário o
pode ser aproximada pela série na Equação 11.18. Escreva valor de x (para |x| < 1) e o erro relativo mínimo desejado.
um programa em Python que calcule essa aproximação para Interrompa as iterações quando o erro for atingido e gere
um número de iterações informado pelo usuário. Calcule um gráfico ilustrando a evolução do erro relativo a cada
o erro relativo em cada passo e, ao final, exiba um gráfico iteração.
com a evolução desse erro.
∞
∞ X (−1)n+1 xn
X ln(n)
n ln(1 + x) = (11.23)
γ= (−1) (11.18) n
n n=1
n=2
√
2. A série de Taylor (ou Maclaurin) para ln(1 + x), válida para 7. A aproximação de x pode ser feita usando a expansão em
|x| < 1, é apresentada na Equação 11.19. Escreva um pro- série de Taylor em torno de a = 1, dada na Equação 11.24.
√
grama em Python que utilize essa série para aproximar o Implemente um programa que calcule x para um x pró-
valor de ln(1 + x) para um dado valor de x, calculando o ximo de 1, utilizando um número de iterações fornecido
erro absoluto em cada iteração e exibindo esses erros em um pelo usuário. Calcule e gere um gráfico do erro relativo em
√
gráfico. relação ao valor real de x ao longo das iterações.
∞
xn ∞
X  
(−1)n+1 X 1/2  
ln(1 + x) = (11.19) √
n x= (x − 1)n (11.24)
n=1 n
n=0

3. A série de Ramanujan para π1 , apresentada na Equação 11.20,

possui convergência extremamente rápida. Escreva um pro- 8. A função arctangente (f (x) = arctan(x)) tem uma série de
grama em Python que solicite ao usuário o número de termos Maclaurin dada na Equação 11.25. Crie um programa em
a serem utilizados para calcular π, computando o erro abso- Python que calcule a aproximação de arctan(x) para um
luto em cada iteração e exibindo esses erros em um gráfico. x fornecido pelo usuário (|x| ≤ 1), interrompendo quando
√ ∞ o erro absoluto for inferior a um ϵ pré-definido. Gere um
1 2 2 X (4n)! 1103 + 26390 n gráfico do erro absoluto em função do número de termos
= (11.20)
π 9801 (n!)4 3964n utilizados.
n=0
∞
4. A constante de Catalan, geralmente denotada por G, é
X (−1)n x2n+1
arctan(x) = (11.25)
um número irracional que surge em várias áreas da ma- 2n + 1
n=0
temática, como teoria dos números, combinatória e aná-
lise. Numericamente, seu valor é aproximadamente: G ≈
0.915965594177219. A constante pode ser definida pela série 9. Desenvolva um programa para calcular a aproximação de
1−x usando a série geométrica (Equação 11.26). O programa
1
infinita na Equação 11.21. Escreva um programa que calcule
G com o número de termos solicitado pelo usuário. Calcule deve solicitar x (|x| < 1) e o número máximo de iterações.
o erro relativo em todas as iterações e mostre, em um gráfico, Para cada iteração, calcule o erro relativo. Ao final, exiba
sua evolução. um gráfico mostrando a convergência do erro relativo.
∞ ∞
X (−1)n 1
G= (11.21)
X n
= x (11.26)
(2n + 1)2 1−x
n=0 n=0

5. A série de Gregory-Leibniz para π é dada pela Equação 11.22. 2

Desenvolva um programa que solicite o número de termos 10. A série de Riemann Zeta (Equação 11.27) converge para π6
N e calcule a aproximação de π. Para cada iteração, calcule quando s = 2. Crie um programa que solicite ao usuário o
o erro absoluto em relação ao valor real de π. Ao final, número de iterações N e calcule a aproximação de f (N ).
gere um gráfico da evolução do erro absoluto em função do Calcule o erro relativo a cada iteração em relação ao valor
2
número de iterações. exato de π6 . Gere um gráfico da evolução do erro relativo
∞ ao longo de N .
π X (−1)n
= (11.22)
4 2n + 1 ∞
n=0
X 1 π2
= (11.27)
n2 6
n=1
 140 Capítulo 11. Erros Numéricos

Folha de Exercício 24: [Solução da Folha de Exercício 24]

P∞
1. O inverso do fatorial, e = n=0 n! 1
, é a série que define a 7. A série de Maclaurin para a função erro erf(x) é apresentada
constante de Euler. Escreva um programa para calcular na Equação 11.33. Desenvolva um programa para calcular a
uma aproximação de e, solicitando o erro absoluto mínimo aproximação de erf(x), solicitando x e o número de termos
desejado. O programa deve parar quando o erro for atin- N . Para cada iteração, calcule o erro relativo. Ao final,
gido. Calcule e visualize (em um gráfico) a evolução do erro plote o gráfico da evolução do erro relativo ao longo das
absoluto a cada iteração. iterações.
∞ ∞
X 1 2 X (−1)n x2n+1
e= (11.28) erf(x) = √ (11.33)
n! π n!(2n + 1)
n=0 n=0

√ P∞ xn
2. A série de Taylor para cosh( x) é dada por n=0 (2n)! . 8. A
√ expansão binomial de (1 + x)α para α = 1/3 (cálculo de
Desenvolva um programa que calcule a aproximação, solici- 3
1 + x) é dada√pela Equação 11.34. Escreva um programa
tando o valor de x e o número de termos N . Calcule o erro para calcular 3 1 + x para x próximo de 0, solicitando x e
relativo para cada iteração e gere um gráfico que mostre a o número de iterações N . Calcule o erro absoluto em cada
evolução do erro. iteração e gere um gráfico da evolução do erro absoluto.
X xn∞ ∞ 
√ 1/3

cosh( x) = (11.29)
X
(1 + x) 1/3
= xn (11.34)
(2n)! n
n=0 n=0

3. O método de Newton para encontrar a raiz de f (x) =

9. A série de Taylor para ln 1−x
1+x
é dada pela Equação 11.35.


√
x3 − γ = 0 (ou seja, 3 γ) é dado pela Equação 11.30. Im-
Implemente um programa que calcule essa aproximação, soli-
plemente um programa que calcule a raiz cúbica de um γ
citando x (|x| < 1) e um erro relativo mínimo ϵ. O programa
fornecido, solicitando a estimativa inicial x0 e o erro rela-
deve parar quando o erro for atingido e gerar um gráfico da
tivo mínimo desejado. Gere um gráfico do erro relativo em
evolução do erro relativo.
função do número de iterações.
∞
x3 − γ 1+x x2n+1
  X
xk+1 = xk − k 2 (11.30) ln =2 (11.35)
3xk 1−x 2n + 1
n=0

4. A aproximação de f (x) = 1+x1

2 pela série de Taylor é dada 10. A integral de Fresnel S(x) tem uma expansão em série de
pela Equação 11.31. Crie um programa para calcular essa Maclaurin dada na Equação 11.36. Crie um programa para
aproximação, solicitando x (|x| < 1) e um número máximo calcular a aproximação de S(x), solicitando x e o número
de iterações. Calcule o erro absoluto para cada iteração e de iterações N . Calcule o erro absoluto em cada iteração e
gere um gráfico da evolução desse erro. gere um gráfico da evolução desse erro.
∞ ∞
1 X
(−1)n (π/2)2n+1 x4n+3
= (−1)n x2n (11.31)
X
1 + x2 S(x) = (11.36)
n=0
(2n + 1)!(4n + 3)
n=0

5. Implemente o método de Monte Carlo para calcular a área 11. Implemente a Quadratura de Gauss-Legendre de N pontos
sob a curva f (x) = sin(x) no intervalo [0, π]. O programa 2
para calcular a integral de f (x) = e−x no intervalo [−1, 1].
deve solicitar o número de pontos N . Estime a integral e
O programa deve solicitar N e exibir a aproximação. Cal-
calcule o erro relativo em relação ao valor exato da integral
Rπ cule o erro relativo para N = 2, 3, 4, 5 em relação ao valor
( 0 sin(x)dx = 2). Ao final, gere um gráfico da evolução do
exato (≈ 1.4936482656). Gere um gráfico do erro relativo
erro relativo à medida que o número de pontos aumenta.
em função do número de pontos N .
6. A série de Madhava-Leibniz para √ π
é dada pela Equa-
4 3 12. A expansão em série de Taylor de √1−x1
é dada pela Equa-
ção 11.32. Escreva um programa que calcule uma aproxima-
ção 11.37. Desenvolva um programa para calcular essa
ção de π com N termos (fornecido pelo usuário). Calcule e
aproximação, solicitando x (|x| < 1) e um erro relativo mí-
gere um gráfico que mostre a evolução do erro relativo em
nimo ϵ. O programa deve parar quando o erro for atingido
relação ao valor real de π a cada iteração.
e gerar um gráfico da evolução do erro relativo ao longo das
∞
π 1 1 1 X (−1)n iterações.
√ = 1− + − +··· = (11.32)
4 3 3·3 5·32 7·3 3 (2n + 1)3n ∞
X (2n)! n
n=0 1
√ = x (11.37)
1−x 4n (n!)2
n=0
 12. Raizes de uma Função

12.1 Fundamentos
As equações é a parte central da modelagem matemática. Resolver equações é uma tarefa
fundamental, pois elas representam relações entre variáveis que descrevem fenômenos físicos,
químicos, biológicos, econômicos ou computacionais. Muitas vezes, compreender e resolver
uma equação significa entender o próprio problema que se está tentando modelar.
Uma equação de uma única variável, também chamada de equação escalar, pode ser
expressa genericamente na forma:

f (x) = 0

onde f (x) é uma função real (ou, em alguns casos, complexa) definida em um domínio de
interesse. Resolver a equação consiste em encontrar todos os valores de x que tornam f (x)
igual a zero.
A solução dessa equação, denominada raiz da função, é um um número (ou um
conjunto de números) que satisfaz à igualdade. Mais formalmente, um número x∗ é dito
uma raiz de f (x) se f (x∗ ) = 0. Dependendo da natureza de f (x), uma equação pode:
• Não tem uma solução real. Exemplo: x2 + 1 = 0, raiz: x = ±i.
• Tem uma única solução. Exemplo: 2x − 4 = 0, raiz: x = 2.
• Tem múltiplas soluções distintas. Exemplo: x2 − 1 = 0, raiz: x = ±1.
• Tem infinitas soluções. Exemplo: sin(x), raiz: x = . . . , −2π, −π, 0, π, 2π, . . ..
Quando a equação é relativamente simples, o valor de x pode ser determinado analiti-
camente. Isso ocorre quando se consegue isolar x explicitamente por meio de operações
matemáticas elementares, ou quando é possível aplicar uma fórmula conhecida, como a
fórmula de Bhaskara (Equação 12.1), para determinar exatamente as raízes de uma
equação do segundo grau. O método analítico é bastante eficiente para funções polinomiais
de grau baixo.
√
−b ± b2 − 4ac
x= (12.1)
2a
142 Capítulo 12. Raizes de uma Função

Embora a fórmula de Bhaskara seja bastante prática para encontrar as raízes de equações
quadráticas, existem muitas funções para as quais as raízes não podem ser determinadas tão
facilmente. À medida que a complexidade da função aumenta, por exemplo, em polinômios
de grau maior que quatro, ou em funções transcendentes como exponenciais, logaritmos,
trigonométricas ou combinações destas, pode não existir uma expressão analítica fechada
para as soluções.
Na verdade, em muitas situações é impossível determinar analiticamente as
raízes de uma equação. Por exemplo, mesmo uma função aparentemente simples como
f (x) = e−x − x não pode ser resolvida de forma exata por métodos analíticos, pois não há
uma fórmula conhecida que permita isolar x nessa equação.
Em casos como esse, a única alternativa é recorrer a métodos numéricos aproxi-
mados para obter soluções com a precisão desejada. Esses métodos iterativos permitem
encontrar aproximações sucessivas para as raízes, dentro de uma tolerância preestabelecida,
e são amplamente utilizados na prática para resolver problemas reais na ciência e na
engenharia.

Tipo de problema Solução analítica?

Equações lineares. Exemplo: ax + b = 0 Sim

2
Equações quadráticas. Exemplo: ax + bx + c = 0 Sim
Equações cúbicas ou biquadráticas Sim
Sistemas lineares bem definidos (Ax = b com det(A) ̸= 0) Sim
Equações com funções inversíveis simples. Exemplo: sin x = c Sim
5
Polinômios de grau ≥ 5. Exemplo: x + x + 1 = 0 Não
Funções transcendentais. Exemplo: e−x = x Não
Funções algébrico-transcendentais. Exemplo: x + ln x = 2 Não
Sistemas não lineares complexos Não
Modelos físicos com múltiplas variáveis acopladas Não
Equações diferenciais ordinárias não lineares Não

Os métodos numéricos podem ser classificados em dois grupos: (i) métodos interva-
lares e (ii) métodos abertos. Cada um desses grupos apresenta características distintas
quanto à forma de aproximação da solução e às garantias de convergência.
Métodos intervalares baseiam-se em um intervalo [a, b] dentro do qual a solução
da equação está contida. Para isso, é necessário que a função mude de sinal, ou seja,
f (a) · f (b) < 0, o que, segundo o Teorema do valor intermediário, garante a existência de
ao menos uma raiz real no intervalo. O método aplica um processo iterativo que reduz
progressivamente o tamanho do intervalo, tornando o intervalo cada vez menor. A principal
vantagem dos métodos intervalares é a garantia de convergência para a solução.
Por outro lado, os métodos abertos não requerem que a solução esteja inicialmente
contida em um intervalo. Em vez disso, esses métodos partem de uma ou mais estimativas
iniciais para a solução, geralmente escolhidas com base de uma análise previa do problema.
Embora os métodos abertos sejam mais rápidos e eficientes em termos computacionais, eles
não oferecem garantia de convergência. Em certos casos, a aproximação pode divergir ou
oscilar indefinidamente se a estimativo inicial não for suficientemente próxima da raiz real.
 12.2 Métodos Gráficos 143

12.2 Métodos Gráficos

Com o avanço da tecnologia, o uso de computadores, softwares gráficos e calculadoras
científicas tornou-se uma prática comum para auxiliar na análise de funções. Quando
dispomos dessas ferramentas, é possível traçar o gráfico de uma função e, por simples
inspeção visual, podemos identificar os pontos em que a curva intercepta o eixo dos
x. Esses pontos correspondem aos valores de x para os quais f (x) = 0, ou seja, são
aproximações iniciais das raízes da função. Por exemplo, considere a função algébrico-
transcendental definida pela Equação 12.2. Essa função combina um termo polinomial x3
com um termo exponencial decrescente e−x . Tal combinação faz com que o comportamento
da função seja não trivial, dificultando a localização precisa de suas raízes somente pela
análise gráfica. Nesses casos, o gráfico pode fornecer uma estimativa inicial.

f (x) = x3 + e−x − 2 (12.2)

f (x)

3
2

x
0.5 1.5 2
−2

f (x) = x3 + e−x − 2
f (0.5) = −1.2685
f (2.0) = 6.135

O gráfico de uma função é uma ferramenta útil para investigar o comportamento da

função e, em particular, para localizar visualmente suas raízes. Ao representar a função no
plano cartesiano, torna-se possível identificar as regiões onde ela cruza o eixo das abscissas,
o que corresponde exatamente aos valores de x para os quais f (x) = 0.
Mesmo sem conhecer a raiz exata, a simples observação de uma mudança de sinal
nos valores da função pode fornecer informações valiosas. Por exemplo, se sabemos que
f (a) > 0 e f (b) < 0, ou vice-versa, isso indica que a função passou de positiva para negativa
(ou o contrário) no intervalo (a, b). Nessas condições, e desde que a função seja contínua
nesse intervalo, o Teorema do Valor Intermediário garante a existência de pelo menos uma
raiz nesse trecho. Isso significa que podemos afirmar com segurança que há ao menos um
valor c ∈ (a, b) tal que f (c) = 0.
Portanto, o método gráfico não apenas auxilia na visualização das raízes, como também
orienta a escolha de intervalos apropriados para a aplicação de métodos numéricos mais
precisos, como o Método da Bisseção, Falsa Posição e da Secante, como veremos mais
adiante.
 144 Capítulo 12. Raizes de uma Função

12.3 Método da Bisseção

O método da bisseção, também conhecido como método da divisão do intervalo ao meio
ou método de Bolzano, é uma técnica numérica utilizada para encontrar raízes de funções
em um determinado intervalo. Esse método é amplamente utilizado em diversas aplicações
da matemática, engenharia e computação numérica, sendo uma ferramenta fundamental
para a resolução de equações que não admitem uma solução algébrica exata.
O método baseia-se no Teorema do valor intermediário, que afirma: se uma função
contínua f (x) assume valores de sinais opostos em dois pontos distintos de um intervalo
[a, b], então existe pelo menos um ponto c ∈ [a, b] tal que f (c) = 0. Essa ideia é aplicada
iterativamente, refinando-se o intervalo a cada passo, para obter aproximações cada vez
mais precisas da raiz.
Em geral, se f (x) for real e contínua no intervalo (xa , xb ) (sendo a < b), f (xa ) e f (xb )
tiverem sinais opostos, isto é:

f (xa )f (xb ) < 0

então existe pelo menos uma raiz real no intervalo [xa , xb ]. Em seguida, é criado um novo
ponto médio entre o intervalo (xa , xb ) chamado xc . Finalmente, atualizamos os valores do
intervalo (xa , xb ) da seguinte forma:

x b = x c se f (xa )f (xc ) < 0


(xa , xb ) = x =x
a c se f (xa )f (xc ) > 0


A raiz é x se f (xa )f (xc ) = 0
c

Esse processo é repetido sucessivamente, reduzindo o tamanho do intervalo a cada

iteração, até que a raiz seja determinada com a precisão desejada. O método da bisseção é
uma abordagem robusta e confiável, pois sempre converge para uma solução, desde que a
função seja contínua no intervalo considerado. Mas ele possui algumas desvantagens que
podem torná-lo menos eficiente em algumas situações. As principais são:
• Convergência Lenta - O método da bisseção possui uma taxa de convergência
linear, o que implica que a redução do erro ocorre de forma relativamente devagar.
Dessa forma, um grande número de iterações pode ser necessário para atingir um
nível de precisão satisfatório.
• Necessidade de um Intervalo Inicial Bem Definido - Para que o método
seja aplicado corretamente, é essencial escolher um intervalo [a, b] no qual a função
apresente uma mudança de sinal, ou seja, f (a) · f (b) < 0. Se esse intervalo não for
identificado adequadamente, o método pode falhar ou exigir análises adicionais para
garantir sua aplicabilidade.
• Funciona Apenas para Funções Contínuas - Caso a função possua desconti-
nuidades dentro do intervalo, o método pode fornecer resultados incorretos ou não
convergir adequadamente para uma raiz real.
• Limitação na Identificação de Raízes Múltiplas - O método da bisseção é capaz
de encontrar apenas uma raiz dentro do intervalo especificado. Se houver múltiplas
raízes nesse intervalo, o método pode convergir para apenas uma delas, sem fornecer
informações sobre as demais.
12.3 Método da Bisseção 145

f (x)

x
0.2 0.4 0.6 0.8 1
−2
xa = (0.2, 1.2) xc = (0.6, −1) xb = (1.0, −1)

f (x)

x
0.2 0.4 0.6 0.8
−2
xa = (0.2, 1.2) xc = (0.4, 0.4256) xb = (0.6, −0.2704)

1
f (x)

x
0.4 0.5 0.6

−1
xa = (0.4, 0.4256) xc = (0.5, 0.0625) xb = (0.6, −0.2704)

1
f (x)

x
0.5 0.55 0.6

−1
xa = (0.5, 0.06250) xc = (0.55, −0.10849) xb = (0.6, −0.27040)

1
f (x)

x
0.5 0.51 0.52 0.53 0.54 0.55 0.56

−1
xa = (0.5, 0.06250) xc = (0.525, −0.02403) xb = (0.55, −0.10849)

Figura 12.1: Método da bisseção. São mostrados os pontos do intervalo [xa ,xb ] (vermelho)
e o ponto médio xc (azul). O intervalo é atualizado até uma aproximação suficiente da raiz.
146 Capítulo 12. Raizes de uma Função

Provas Anteriores: 1
[Prova 2024.1] - Utilize o Método da Bisseção para identificar a raiz da função f (x) =
x6 − 2x5 + 1. Considere o intervalo inicial [1.8, 2.1] e realize a aproximação até a quarta iteração.
Realize os calculos com pelo menos cinco casas decimais. Por fim, use o valor exato da raiz
(x ≈ 1.965948236645485) para estimar o erro absoluto e o erro relativo da aproximação obtida.
Primeira iteração (i=1) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––

Valores iniciais__: xa = 1.8, xb = 2.1

Calculando f(x)__: f (xa ) = (1.8)6 − 2(1.8)5 + 1 ≈ −2.77914

f (xb ) = (2.1)6 − 2(2.1)5 + 1 ≈ 5.08410

xa + xb 1.8 + 2.1
Calculando xc__: xc = = = 1.95000
2 2
Calculando f(xc)__: f (xc ) ≈ −0.40975

Analisando o sinal__: f (xa ) · f (xc ) > 0 ⇒ xa = xc

Segunda iteração (i=2) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––

Novo intervalo__: xa = 1.95, xb = 2.1

Calculando f(x)__: f (xa ) ≈ −0.40975

f (xb ) ≈ 5.08410
1.95 + 2.1
Calculando xc__: xc = = 2.02500
2
Calculando f(xc)__: f (xc ) ≈ 1.85127

Analisando o sinal__: f (xa ) · f (xm ) < 0 ⇒ xb = xc

Terceira iteração (i=3) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––

Novo intervalo__: xa = 1.95, xb = 2.02500

Calculando f(x)__: f (xa ) ≈ −0.40975

f (xb ) ≈ 1.85127
1.95 + 2.02500
Calculando xc__: xc = = 1.98750
2
Calculando f(xc)__: f (xc ) ≈ 0.61234

Analisando o sinal__: f (xa ) · f (xc ) < 0 ⇒ xb = xc

Quarta iteração (i=4) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––

Novo intervalo__: xa = 1.95000, xb = 1.98750

1.95 + 1.98750
Calculando xc__: xc = = 1.96875
2
Iterações:

i xa f (xa ) xb f (xb ) xc f (xc ) Localização da raiz

1 1.80000 -2.77914 2.10000 5.08410 1.95000 -0.40975 dir →

2 1.95000 -0.40975 2.10000 5.08410 2.02500 1.85127 esq ←
3 1.95000 -0.40975 2.02500 1.85127 1.98750 0.61234 esq ←
4 1.95000 -0.40975 1.98750 0.61234 1.96875 0.07572 esq ←
 12.4 Método da Falsa Posição 147

12.4 Método da Falsa Posição

Embora o método da bisseção seja uma técnica perfeitamente válida e confiável para
determinar raízes de equações, ele apresenta uma abordagem do tipo força bruta, que
pode ser relativamente ineficiente em termos de velocidade de convergência. Sua principal
limitação está no fato de que, ao dividir repetidamente o intervalo [xa , xb ] ao meio, o
método não considera a magnitude dos valores da função nos extremos do intervalo, como
f (xa ) e f (xb ). Assim, a escolha do novo ponto de teste xc é sempre o ponto médio do
intervalo atual, sem levar em conta a forma da curva ou o comportamento da função nesse
intervalo. Como resultado, a convergência para a raiz ocorre de forma garantida, mas pode
ser lenta, especialmente quando a função é bastante inclinada em uma das extremidades
do intervalo.
Por outro lado, o método da Falsa Posição (também conhecido como Regula Falsi)
introduz uma estratégia mais inteligente e, frequentemente, mais eficiente. Em vez de
simplesmente dividir o intervalo, esse método utiliza os valores da função nos pontos
extremos para realizar uma interpolação linear. Ou seja, ele traça uma reta secante entre
os pontos (xa , f (xa )) e (xb , f (xb )) e calcula o ponto em que essa reta intercepta o eixo x.
Esse ponto de interseção, denotado por xr , é usado como uma estimativa melhorada da
raiz.
O raciocínio por trás do método é que, se a função fosse aproximadamente linear no
intervalo considerado, a raiz estaria próxima da interseção da reta secante com o eixo
x. Essa estimativa leva em conta tanto a posição dos extremos quanto a magnitude dos
valores de f (x) nesses pontos, o que tende a produzir uma aproximação mais próxima da
raiz real, especialmente nas primeiras iterações. A fórmula utilizada para encontrar o novo
valor xr é dada pela Equação 12.3.

f (xb )(xa − xb )
xr = xb − (12.3)
f (xa ) − f (xb )

Após o cálculo de xr , o método verifica o sinal do produto f (xa )f (xr ) para determinar
em qual subintervalo a raiz está localizada, tal como na bisseção. O novo intervalo é então
escolhido de forma a preservar a mudança de sinal entre os extremos, o que garante que a
raiz permaneça contida no intervalo. Esse processo é repetido iterativamente até que a
aproximação atinja a precisão desejada.
Apesar de sua eficiência superior em muitos casos, o método da Falsa Posição pode
apresentar lentidão na convergência se um dos extremos do intervalo permanecer fixo por
muitas iterações. Isso ocorre quando o valor de f (x) em um dos extremos é muito pequeno
em relação ao outro, o que faz com que a posição de xr não varie significativamente entre
as iterações.
Dessa forma, o Método da Falsa Posição preserva a robustez e a garantia de convergência
do Método da Bisseção, mas, por empregar uma estratégia de interpolação linear, tende a
exigir menos iterações para alcançar um determinado nível de precisão. Isso o torna, em
muitas situações práticas, uma alternativa mais eficiente e atrativa para a localização de
raízes.
148 Capítulo 12. Raizes de uma Função

f (x)
6

4
xb

2
xr
x
0.5 1 1.5 2 2.5 3 3.5 4

−2

−4
xa

f (x)
6

4
xb

2
xr
x
1 1.5 2 2.5 3 3.5

−2

xa
−4

f (x)
6

4
xb

2
xr

x
1.6 1.8 2 2.2 2.4 2.6 2.8 3 3.2 3.4 3.6

xa

Figura 12.2: Método da Falsa Posição. São mostrados os pontos do intervalo [xa ,xb ]
(vermelho) e o ponto xr , que intercepta o eixo x (azul). O intervalo é atualizado até uma
aproximação suficiente da raiz.
12.4 Método da Falsa Posição 149

Exemplo: 2
Utilize o Método da Falsa Posição para identificar a raiz da função f (x) = e−x − x. Considere
o intervalo inicial [0, 1] e realize a aproximação até a quarta iteração. Realize os calculos com pelo
menos cinco casas decimais. Por fim, use o valor exato da raiz (x ≈ 0.567143290409783) para
estimar o erro absoluto e o erro relativo da aproximação obtida.

Solução:

Primeira iteração (i=1)

Intervalo inicial___: xa = 0, xb = 1
Calculando f(x)_____: f (xa ) = 1, f (xb ) ≈ −0.632121
−0.632121(0−1)
Calculando xr_______: xr = 1 − 1−(−0.632121)
≈ 0.612699
Calculando f(xr)____: f (0.612699) ≈ 0.542425 − 0.612699 = −0.070274
Análise do sinal____: f (xa )f (xr ) < 0 ⇒ xb = xr

Segunda iteração (i=2)

Intervalo atual_____: xa = 0, xb = 0.612699
Calculando f(x)_____: f (xa ) = 1, f (xb ) ≈ −0.070274
−0.070274(0−0.612699)
Calculando xr_______: xr = 0.612699 − 1−(−0.070274)
≈ 0.572310
Calculando f(xr)____: f (0.572310) ≈ 0.564370 − 0.572310 = −0.007940
Análise do sinal____: f (xa )f (xr ) < 0 ⇒ xb = xr

Terceira iteração (i=3)

Intervalo atual_____: xa = 0, xb = 0.572310
Calculando f(x)_____: f (xa ) = 1, f (xb ) ≈ −0.007940
−0.007940(0−0.572310)
Calculando xr_______: xr = 0.572310 − 1−(−0.007940)
≈ 0.567145
Calculando f(xr)____: f (0.567145) ≈ 0.567143 − 0.567145 = −0.000877
Análise do sinal____: f (xa )f (xr ) < 0 ⇒ xb = xr

Quarta iteração (i=4)

Intervalo atual_____: xa = 0, xb = 0.567145
Calculando f(x)_____: f (xa ) = 1, f (xb ) ≈ −0.000002
−0.000002(0−0.567145)
Calculando xr_______: xr = 0.567145 − 1−(−0.000002)
≈ 0.567143
Calculando f(xr)____: f (0.567143) ≈ 0.567143 − 0.567143 = 0.000098
Análise do sinal____: f (xa )f (xr ) > 0 ⇒ xa = xr

Resultado___________: x ≈ 0.567143

Iterações:

Iteração xa xb xr f (xr ) Intervalo novo

1 0.000000 1.000000 0.612699 -0.070274 [0.000000, 0.612699]

2 0.000000 0.612699 0.572310 -0.007940 [0.000000, 0.572310]
3 0.000000 0.572310 0.567145 -0.000877 [0.000000, 0.567145]
4 0.000000 0.567145 0.567143
 150 Capítulo 12. Raizes de uma Função

12.5 Método da Secante

O método da secante é um algoritmo numérico utilizado para encontrar aproximações
sucessivas para a raiz de uma função não linear f (x) = 0. Ele baseia-se na construção
de uma reta secante entre dois pontos da curva da função,(xi−1 , f (xi−1 )) e (xi , f (xi )).
A interseção dessa reta com o eixo x fornece a próxima aproximação da raiz, xi+1 . O
processo é iterativo e se repete até que a diferença entre aproximações consecutivas seja
suficientemente pequena, ou até que o valor de f (x) se aproxime de zero.
A fórmula iterativa do método é dada por:

f (xi )(xi−1 − xi )
xi+1 = xi − (12.4)
f (xi−1 ) − f (xi )

Geometricamente, é como projetar a reta que une os pontos (xi−1 , f (xi−1 )) e (xi , f (xi ))
até cruzar o eixo x, utilizando esse ponto de interseção como uma nova estimativa da raiz.
Diferentemente de métodos como o da bisseção ou da falsa posição, o método da
secante não exige que a função mude de sinal no intervalo entre as estimativas iniciais.
Por esse motivo, não é classificado como um método intervalar. No entanto, exige duas
aproximações iniciais razoavelmente próximas da raiz e é sensível à escolha desses valores.
A Figura 12.3 ilustra graficamente o funcionamento do método da secante, mostrando
a reta construída entre dois pontos da função e sua interseção com o eixo x, que representa
a próxima estimativa da raiz.

f (x) f (x)
40 40 f (xi−1 )
f (xi )

30 30

20 20
f (xi−1 )
10 10
f (xi )
x x
2 xi+1 6 8 2 xi+1 6 8

−10 −10

f (x) f (x)
20 3

f (xi−1 )
2

10
1
f (xi−1 ) f (xi )
f (xi ) x
x
3.4 xi+1 3.8 4
2 3 xi+1 5 6

−5 −1

Figura 12.3: Aplicação do método da Secante à função x2 − 3x − 2 ao longo de 6 iterações

12.5 Método da Secante 151

Provas Anteriores: 2
[Prova 2024.1] - Utilize o método da secante para identificar a raiz da função f (x) = x3 + x − 1.
Considere os pontos iniciais x0 = 4 e x1 = 1.5 e realize a aproximação até a terceira iteração.
Realize os calculos com pelo menos cinco casas decimais. Por fim, use o valor exato da raiz
(x ≈ 0.682327803828019) para estimar o erro absoluto e o erro relativo da aproximação obtida.

Primeira iteração (i=1) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––

Valores iniciais__: x0 = 4, x1 = 1.5

Calculando f(x)__: f (x0 ) = 43 + 4 − 1 = 64 + 4 − 1 = 67

f (x1 ) = 1.53 + 1.5 − 1 = 3.375 + 1.5 − 1 = 3.87500

f (x1 ) · (x0 − x1 )
Calculando x2__: x2 = x1 −
f (x0 ) − f (x1 )
3.875 · (4 − 1.5)
x2 = 1.5 −
67 − 3.875
3.875 · 2.5
x2 = 1.5 −
63.125

x2 = 1.5 − 0.15347 ≈ 1.34653

Segunda iteração (i=2) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––

Valores iniciais__: x1 = 1.5, x2 = 1.34653

Calculando f(x)__: f (x1 ) = 3.87500

f (x2 ) = 1.346533 + 1.34653 − 1 = 2.78798

f (x2 ) · (x1 − x2 )
Calculando x3__: x3 = x2 −
f (x1 ) − f (x2 )
2.78798 · (1.5 − 1.34653)
x3 = 1.34653 −
3.875 − 2.78798

x3 ≈ 0.95291

Terceira iteração (i=3) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––

Valores iniciais__: x2 = 1.34653, x3 = 0.95291

Calculando f(x)__: f (x2 ) = 2.78798

f (x3 ) = 0.952913 + 0.95291 − 1 = 0.81819

f (x3 ) · (x2 − x3 )
Calculando x4__: x4 = x3 −
f (x2 ) − f (x3 )
0.81819 · (1.34653 − 0.95291)
x4 = 0.95291 −
2.78798 − 0.81819

x4 ≈ 0.78941

Erro Absoluto__: Eabs ≈ 0.10708219617198089

Iterações:

i xi xi−1 f (xi ) f (xi−1 ) xi+1

1 1.50000 4.00000 3.87500 67.0000 1.34653

2 1.34653 1.50000 2.78798 3.87500 0.95291
3 0.95291 1.34653 0.81819 2.78798 0.78941
152 Capítulo 12. Raizes de uma Função

Exemplo: 3
Use o método da Secante para identificar a raiz da função f (x) = x2 + 2x − 1 sendo x1 = 1 e x0 = 1.5.
Realize a aproximação do resultado com cinco casas decimais até a terceira iteração.
f (xi )(xi−1 − xi )
xi+1 = xi −
f (xi−1 ) − f (xi )

i=1 (primeira iteração)

Sendo i = 1, calculamos f (xi ):

f (x1 ) = x2 + 2x − 1 = (12 ) + (2 × 1) − 1 = 2

Agora, calculando f (xi−1 ):

f (x0 ) = (1.52 ) + (2 × 1.5) − 1 = 4.25

Finalmente, calculamos xi+1 :

f (xi )(xi−1 − xi ) 2 × (1.5 − 1)

xi+1 = xi − = 1− = 0.55556
f (xi−1 ) − f (xi ) 4.25 − 2
logo, x2 = 0.55556.

i=2 (segunda iteração)

Sendo i = 2, calculamos f (xi ). Temos: x2 = 0.55556, logo f (x2 ) = 0.41977

Agora, calculando f (xi−1 ) = f (x1 ). Temos x1 = 1, logo f (x1 ) = 2

Finalmente, calculamos o novo valor de xi+1 = x3 = 0.43750

logo, x3 = 0.43750.

i=3 (terceira iteração)

Sendo i = 3, calculamos f (xi ). Temos: x3 = 0.43750, logo f (x3 ) = 0.06641

Agora, calculando f (xi−1 ) = f (x2 ). Temos x2 = 0.55556, logo f (x2 ) = 0.41977

Finalmente, calculamos o novo valor de xi+1 = x4 = 0.41531

Resultado: ≃ 0.41531
 12.6 Método da Secante Modificado 153

12.6 Método da Secante Modificado

Em vez de usar dois valores arbitrários (xi e xi−1 ), utiliza apenas xi . Realiza uma pequena
fração de pertubação (δ) da variável independente para fazer uma estimativa de xi+1 .

δxi f (xi )
xi+1 = xi −
f (xi + δxi ) − f (xi )

Exemplo: 4
Use o método da Secante Modificado para identificar a raiz da função f (x) = x2 + 2x − 1 sendo
x1 = 2 e δ = 0.1. Realize a aproximação do resultado com cinco casas decimais até a terceira
iteração.

δxi f (xi )
xi+1 = xi −
f (xi + δxi ) − f (xi )
i=1 (primeira iteração)
Sendo, x1 = 2 e δ = 0.1, calculamos f (x1 ), sendo:

f (x1 ) = x2 + 2x − 1 = (22 ) + (4) − 1 = 7

Depois, calculamos o valor de x1 + δx1 , sendo:

x1 + δx1 = 2 + (0.1 × 2) = 2.2

Agora, calculamos f (x1 + δx1 ):

f (x1 + δx1 ) = 2.22 + (2 × 2.2) − 1 = 8.24

Finalmente, calculamos o valor de xi+1 :

δxi f (xi ) 0.1 × 2 × 7

xi+1 = xi − = 2− = 0.87097
f (xi + δxi ) − f (xi ) 8.24 − 7
Então, x2 = 0.87097.

i=2 (segunda iteração)

Sendo, x2 = 0.87097 e δ = 0.1, calculamos f (x2 ), sendo: f (x2 ) = 1.50053
Depois, calculamos o valor de x2 + δx2 , sendo: 0.95807
Agora, calculamos f (x2 + δx2 ), sendo: 1.83404
Finalmente, calculamos o valor de xi+1 , sendo: 0.47910

para i=3 (terceira iteração)

Sendo, x3 = 0.47910 e δ = 0.1, calculamos f (x3 ), sendo: f (x3 ) = 0.18774
Depois, calculamos o valor de x3 + δx3 , sendo: 0.52701
Agora, calculamos f (x3 + δx3 ), sendo: 0.33176
Finalmente, calculamos o valor de xi+1 , sendo: 0.41665
Resultado: 0.41665
154 Capítulo 12. Raizes de uma Função

Provas Anteriores: 3
[Prova 2024.2] - Use o método da Secante modificada para identificar a raiz da função f (x) =
x3 − 4x2 − 3. Considere o valor de x1 = 8 e δ = 0.1. Realize a aproximação do resultado com cinco
casas decimais e até a quinta iteração.
Primeira iteração (i=1) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Valores iniciais__: x1 = 8.0, δ = 0.1
Calculando xid__: xid = xi + (δ · xi ) = 8.8
Calculando f(x)__: f (x1 ) = 253
f (xi d) = 368.712
Calculando xi+1__: xi+1 = xi − f (xi δxi f (xi )
+δxi )−f (xi )
= 6.25083
Segunda iteração (i=2) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Valores iniciais__: x2 = 6.25083, δ = 0.1
Calculando xid__: xid = xi + (δ · xi ) = 6.87591
Calculando f(x)__: f (x2 ) = 84.94640
f (xi d) = 132.96793
Calculando xi+1__: xi+1 = xi − f (xi δxi f (xi )
+δxi )−f (xi )
= 5.14511
Terceira iteração (i=3) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Valores iniciais__: x3 = 5.14511, δ = 0.1
Calculando xid__: xid = xi + (δ · xi ) = 5.65962
Calculando f(x)__: f (x3 ) = 27.31353
f (xi d) = 50.15983
Calculando xi+1__: xi+1 = xi − f (xi δxi f (xi )
+δxi )−f (xi )
= 4.52999
Quarta iteração (i=4) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Valores iniciais__: x4 = 4.52999, δ = 0.1
Calculando xid__: xid = xi + (δ · xi ) = 4.98299
Calculando f(x)__: f (x4 ) = 7.87582
f (xi d) = 21.40779
Calculando xi+1__: xi+1 = xi − f (xi δxi f (xi )
+δxi )−f (xi )
= 4.26634
Quinta iteração (i=5) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Valores iniciais__: x5 = 4.26634, δ = 0.1
Calculando xid__: xid = xi + (δ · xi ) = 4.69297
Calculando f(x)__: f (x5 ) = 1.84783
f (xi d) = 12.26206
Calculando xi+1__: xi+1 = xi − f (xi δxi f (xi )
+δxi )−f (xi )
= 4.19064

Iterações:

i xi f (xi ) xi + δ f (xi + δ) xi+1

1 8.00000 253.00000 8.80000 368.71200 6.25083

2 6.25083 84.94640 6.87591 132.96793 5.14511
3 5.14511 27.31353 5.65962 50.15983 4.52999
4 4.52999 7.87582 4.98299 21.40779 4.26634
5 4.26634 1.84783 4.69297 12.26206 4.19064
 12.6 Método da Secante Modificado 155

Folha de Exercício 25: [Solução da Folha de Exercício 25]

1. Use o método da bisseção para encontrar uma aproxima- obtidos pelo método da bisseção.
ção da raiz da equação f (x) = cos(x) − x no intervalo [0, 1].
15. Utilize o método da secante com x0 = 2 e x1 = 2.5 para
Realize cinco iterações e apresente os valores intermediários.
resolver f (x) = x ln(x) − 1. Faça até seis iterações ou até
2. Escreva um programa em Python para encontrar a raiz atingir erro inferior a 10−3 .
da função f (x) = x6 − 2x2 + 4x − 8 no intervalo [1, 2] usando √
16. Resolva numericamente a equação f (x) = x − cos(x) com
o método da falsa posição. Apresente o erro relativo em
o método da secante. Utilize aproximações iniciais x0 = 0.5
cada iteração e pare quando o erro for inferior a 1 × 10−4 .
e x1 = 1.
Utilize o valor x = 1.357407055077686 como referência para
calcular o erro relativo. 17. Encontre a raiz de f (x) = x2 − tan(x) usando o método da
secante modificada. Use aproximação inicial x0 = 1.2 e pare
3. A equação f (x) = e−x − x tem uma raiz próxima de
quando o erro for inferior a 0,001.
x = 0.5. Utilize o método da secante com aproximações ini-
ciais x0 = 0 e x1 = 1 para encontrar a raiz. Faça no máximo 18. Use o método da bisseção para encontrar uma raiz de
5 iterações. f (x) = x3 − x − 2 no intervalo [1, 2] com precisão de 10−4 .
Apresente o número de iterações necessário.
4. Utilize o método da secante modificada para resolver a
equação f (x) = x2 − 2 com uma aproximação inicial x0 = 2.1 19. A equação f (x) = ex − 3x possui uma raiz entre x = 0 e x = 2.
e δ = 0.1. Faça no máximo 5 iterações. Aplique o método da falsa posição por quatro iterações e
apresente os valores de xr , f (xr ) e o erro relativo.
5. Uma esfera de raio R = 2 m tem seu volume de água descrito
πh2 (3R−h) 20. Considere f (x) = sin(x) − x2 . Use o método da bisseção para
por V (h) = 6 . Encontre a profundidade h que ar-
mazena 10 m3 usando o método da falsa posição com três encontrar uma raiz no intervalo [1, 3]. Determine o número
iterações. Calcule o erro relativo em cada passo. de iterações para atingir εs = 0,01.

6. A função f (x) = ln(x) − sin(x) possui uma raiz entre x = 2 21. A equação f (x) = x3 − 4x + 1 possui uma raiz entre x = 0
e x = 3. Use o método da bisseção para localizá-la com e x = 2. Aplique o método da falsa posição até que o erro
precisão de 10−5 . Mostre os valores de a, b, xr e f (xr ) em relativo seja menor que 1%.
cada iteração. 22. Compare a taxa de convergência entre os métodos da bisse-
−x
7. A equação f (x) = xe − 0.1 descreve o modelo de um cir- ção e da falsa posição para f (x) = ex − x2 no intervalo [0, 2].
cuito elétrico. Utilize o método da secante com aproximações Faça cinco iterações de cada método.
iniciais x0 = 0.1 e x1 = 1 para encontrar a raiz. Realize até 23. Use o método da secante para encontrar a raiz da função
6 iterações e mostre o erro aproximado em cada uma. f (x) = ln(x) − x1 com aproximações x0 = 1 e x1 = 2. Faça
8. Utilize o método da falsa posição para encontrar a raiz de no máximo oito iterações.
f (x) = x3 − 6x2 + 11x − 6 no intervalo [1, 3.5]. Sabendo que 24. A equação f (x) = x1 − x tem uma raiz entre x = 0.5 e x = 2.
a raiz real é x = 1, calcule o erro verdadeiro ao final de cada Utilize o método da secante modificada e calcule até erro
iteração. menor que 10−4
9. Considere a equação f (x) = tan(x) − x. Use o método da 25. Uma equação de engenharia é dada por f (x) = x3 +x sin(x)−
secante modificada com aproximação inicial x0 = 4.5 para 1. Resolva-a usando o método da falsa posição entre x = 0 e
encontrar uma raiz no intervalo [4, 5]. Apresente os valores x = 1. Mostre as quatro primeiras iterações
obtidos nas 5 primeiras iterações.
26. Uma equação de engenharia é dada por f (x) = x3 +x sin(x)−
10. Uma viga com comportamento não linear é modelada por 1. Resolva-a usando o método da falsa posição entre x = 0 e
f (x) = x3 + 2x2 − 5x − 6. Use o método da bisseção e o x = 1. Mostre as quatro primeiras iterações
método da falsa posição para encontrar a raiz entre x = 2
e x = 3. Compare os resultados e discuta o número de 27. Use o método da falsa posição para resolver f (x) = cos(x)−x
iterações necessário para atingir εs < 1%. entre x = 0 e x = 1. Determine o número de iterações para
obter εs < 0,01.
11. Utilize o método da secante para encontrar a raiz da função
f (x) = x2 − 5 com aproximações iniciais x0 = 2 e x1 = 3. 28. Resolva f (x) = x3 −2x−5 com o método da bisseção. Utilize
Faça cinco iterações e apresente os resultados. o intervalo [2, 3] e calcule até obter erro inferior a 0,1%.

12. Resolva f (x) = cos(x) − x2 no intervalo [0, 1] com o método 29. Escreva um programa que aplique os métodos da bisseção,
da bisseção. Mostre os valores intermediários e pare quando falsa posição e secante para resolver f (x) = x2 − 3. Compare
o erro relativo for menor que 0,5%. o número de iterações para cada método.

13. A equação f (x) = ln(x2 + 1) − x tem uma raiz próxima de 30. A equação f (x) = x5 − 3x3 + 2x − 7 possui uma raiz real
x = 0.6. Use o método da secante modificada para encontrar positiva. Utilize o método da secante com aproximações
essa raiz com precisão de 10−5 . iniciais x0 = 1 e x1 = 2 para encontrar essa raiz com precisão
de 10−4 . Apresente os valores de x, f (x) e o erro relativo
14. Use o método da falsa posição para resolver f (x) = x3 + aproximado em cada iteração.
4x2 − 10 no intervalo [1, 2]. Compare os resultados com os
 156 Capítulo 12. Raizes de uma Função

Folha de Exercício 26: [Solução da Folha de Exercício 26]

B
1. Use o método da bisseção para encontrar uma aproximação
da raiz da Equação 12.5 no intervalo [0, 1]. Realize cinco
iterações e apresente os valores intermediários.
f (x) = xe−x − 0.2 (12.5)
y
Ac
3m
2. Escreva um programa em Python para determinar a raiz
da Equação 12.6 no intervalo [0.5, 2], utilizando o método
da bisseção. Calcule até uma aproximação com precisão de 7. Você está desenvolvendo o projeto de um reservatório
10−5 e comente sobre o comportamento da convergência. esférico destinado ao abastecimento de água de uma pequena
comunidade. O volume de água armazenado no tanque pode
f (x) = ln(x) + x2 − 2 (12.6)
ser determinado pela seguinte equação:
3. Escreva um programa em Python para encontrar uma apro-
ximação da raiz da função Equação 12.7 usando o método πh2 (3R − h)
V (h) = (12.11)
da bisseção no intervalo [0, 1]. O programa deve imprimir 6
os valores de a, b, c e f (c) em cada passo.
em que V representa o volume de água em metros cúbicos
f (x) = e−x − sin(x) (12.7) (m3 ), h é a profundidade da água dentro do tanque em
metros (m), e R é o raio do tanque, também em metros (m).
4. A função da Equação 12.8 apresenta comportamento oscila- Sabendo que o raio do tanque é R = 3 m, determine qual
tório. Escreva um programa em Python usando o método deve ser a profundidade h para que o volume armazenado
da bisseção para localizar uma raiz no intervalo [1, 2]. Repe- seja de 30 m3 . Utilize o método gráfico e método da falsa
tir as iterações até que o erro absoluto entre aproximações posição para encontrar a resposta.
consecutivas seja menor que ε = 10−4 .
f (x) = e−x cos(2x) − 0.1 (12.8)
�
5. A velocidade v do pára-quedista em queda livre é dada
pela Equação 12.9, onde g = 9.8m/s2 . Para um pára-
quedista com um coeficiente de arrasto c = 15kg/s, calcule
a massa m para que a velocidade seja v = 35m/s em t = 9s. � �
Use o método da falsa posição para determinar m com 10
iterações.
gm
 
v= 1 − e−(c/m)t (12.9)
c
8. Encontre a raiz real positiva de f (x) = x4 − 8x3 − 35x2 +
450x − 1001 usando o método da falsa posição. Use aproxi-
6. Água está escoando em um canal trapezoidal a uma vazão
mações iniciais xa = 4.5 e xb = 6. Calcule os erros absoluto
de Q = 20m3 /s. A profundidade crítica y para tal canal
e relativo baseado no fato de que a raiz é 5.60979001912047.
deve satisfazer a Equação 12.10, onde g = 9.81 m/s2 , Ac é a
Use um gráfico para explicar seus resultados.
área da seção transversal (m2 ), e B é a largura do canal na
superfície (m).
9.
Q2
f (y) = 1 − B (12.10) 10.
gA3c
Nosso objetivo é encontar a profundidade crítica y tal que 11.
f (y) = 0. Para esse caso, a largura e a área transversal 12.
podem ser relacionadas à profundidade y por:
13.
y2
B = 3+y e Ac = 3y + 14.
2
Encontre a profundidade crítica usando (a) o método gráfico, 15.
(b) a bissecção e (c) a falsa posição. Para (b) e (c), use
16.
aproximações iniciais para a profundidade y com os valores
xa = 0.5 e xb = 2.5. 17.
 12.6 Método da Secante Modificado 157

Folha de Exercício 27: [Solução da Folha de Exercício 27]

1. Use o método da bisseção para encontrar uma aproxima- obtidos pelo método da bisseção.
ção da raiz da equação f (x) = cos(x) − x no intervalo [0, 1].
15. Utilize o método da secante com x0 = 2 e x1 = 2.5 para
Realize cinco iterações e apresente os valores intermediários.
resolver f (x) = x ln(x) − 1. Faça até seis iterações ou até
2. Escreva um programa em Python para encontrar a raiz da atingir erro inferior a 10−3 .
função f (x) = x3 − 2x2 + 4x − 8 no intervalo [1, 3] usando o √
16. Resolva numericamente a equação f (x) = x − cos(x) com
método da falsa posição. Apresente o erro relativo em cada
o método da secante. Utilize aproximações iniciais x0 = 0.5
iteração e pare quando o erro for inferior a 1 × 10−6 . Utilize
e x1 = 1.
o valor x = 1.89882945773481 como referência para calcular
o erro relativo. 17. Encontre a raiz de f (x) = x2 − tan(x) usando o método da
secante modificada. Use aproximação inicial x0 = 1.2 e pare
3. A equação f (x) = e−x − x tem uma raiz próxima de
quando o erro for inferior a 0,001.
x = 0.5. Utilize o método da secante com aproximações ini-
ciais x0 = 0 e x1 = 1 para encontrar a raiz. Faça no máximo 18. Use o método da bisseção para encontrar uma raiz de
5 iterações. f (x) = x3 − x − 2 no intervalo [1, 2] com precisão de 10−4 .
Apresente o número de iterações necessário.
4. Utilize o método da secante modificada para resolver a equa-
ção f (x) = x2 − 2 com uma aproximação inicial x0 = 1.5. 19. A equação f (x) = ex − 3x possui uma raiz entre x = 0 e x = 2.
Calcule até que o erro relativo seja menor que 0,01%. Aplique o método da falsa posição por quatro iterações e
apresente os valores de xr , f (xr ) e o erro relativo.
5. Uma esfera de raio R = 2 m tem seu volume de água descrito
πh2 (3R−h) 20. Considere f (x) = sin(x) − x2 . Use o método da bisseção para
por V (h) = 6 . Encontre a profundidade h que ar-
mazena 10 m3 usando o método da falsa posição com três encontrar uma raiz no intervalo [1, 3]. Determine o número
iterações. Calcule o erro relativo em cada passo. de iterações para atingir εs = 0,01.

6. A função f (x) = ln(x) − sin(x) possui uma raiz entre x = 2 21. A equação f (x) = x3 − 4x + 1 possui uma raiz entre x = 0
e x = 3. Use o método da bisseção para localizá-la com e x = 2. Aplique o método da falsa posição até que o erro
precisão de 10−5 . Mostre os valores de a, b, xr e f (xr ) em relativo seja menor que 1%.
cada iteração. 22. Compare a taxa de convergência entre os métodos da bisse-
−x
7. A equação f (x) = xe − 0.1 descreve o modelo de um cir- ção e da falsa posição para f (x) = ex − x2 no intervalo [0, 2].
cuito elétrico. Utilize o método da secante com aproximações Faça cinco iterações de cada método.
iniciais x0 = 0.1 e x1 = 1 para encontrar a raiz. Realize até 23. Use o método da secante para encontrar a raiz da função
6 iterações e mostre o erro aproximado em cada uma. f (x) = ln(x) − x1 com aproximações x0 = 1 e x1 = 2. Faça
8. Utilize o método da falsa posição para encontrar a raiz de no máximo oito iterações.
f (x) = x3 − 6x2 + 11x − 6 no intervalo [1, 3.5]. Sabendo que 24. A equação f (x) = x1 − x tem uma raiz entre x = 0.5 e x = 2.
a raiz real é x = 1, calcule o erro verdadeiro ao final de cada Utilize o método da secante modificada e calcule até erro
iteração. menor que 10−4
9. Considere a equação f (x) = tan(x) − x. Use o método da 25. Uma equação de engenharia é dada por f (x) = x3 +x sin(x)−
secante modificada com aproximação inicial x0 = 4.5 para 1. Resolva-a usando o método da falsa posição entre x = 0 e
encontrar uma raiz no intervalo [4, 5]. Apresente os valores x = 1. Mostre as quatro primeiras iterações
obtidos nas 5 primeiras iterações.
26. Uma equação de engenharia é dada por f (x) = x3 +x sin(x)−
10. Uma viga com comportamento não linear é modelada por 1. Resolva-a usando o método da falsa posição entre x = 0 e
f (x) = x3 + 2x2 − 5x − 6. Use o método da bisseção e o x = 1. Mostre as quatro primeiras iterações
método da falsa posição para encontrar a raiz entre x = 2
e x = 3. Compare os resultados e discuta o número de 27. Use o método da falsa posição para resolver f (x) = cos(x)−x
iterações necessário para atingir εs < 1%. entre x = 0 e x = 1. Determine o número de iterações para
obter εs < 0,01.
11. Utilize o método da secante para encontrar a raiz da função
f (x) = x2 − 5 com aproximações iniciais x0 = 2 e x1 = 3. 28. Resolva f (x) = x3 −2x−5 com o método da bisseção. Utilize
Faça cinco iterações e apresente os resultados. o intervalo [2, 3] e calcule até obter erro inferior a 0,1%.

12. Resolva f (x) = cos(x) − x2 no intervalo [0, 1] com o método 29. Escreva um programa que aplique os métodos da bisseção,
da bisseção. Mostre os valores intermediários e pare quando falsa posição e secante para resolver f (x) = x2 − 3. Compare
o erro relativo for menor que 0,5%. o número de iterações para cada método.

13. A equação f (x) = ln(x2 + 1) − x tem uma raiz próxima de 30. A equação f (x) = x5 − 3x3 + 2x − 7 possui uma raiz real
x = 0.6. Use o método da secante modificada para encontrar positiva. Utilize o método da secante com aproximações
essa raiz com precisão de 10−5 . iniciais x0 = 1 e x1 = 2 para encontrar essa raiz com precisão
de 10−4 . Apresente os valores de x, f (x) e o erro relativo
14. Use o método da falsa posição para resolver f (x) = x3 + aproximado em cada iteração.
4x2 − 10 no intervalo [1, 2]. Compare os resultados com os
 13. Otimização

13.1 Fundamentos
No sentido mais amplo, otimização é o processo de encontrar a melhor solução possível para
um determinado problema, dentro de um conjunto de restrições. Em termos práticos, isso
significa projetar sistemas ou processos de maneira que se obtenha o máximo desempenho
com o menor custo possível, seja ele energético, ambiental ou computacional. Essa busca
pelo melhor é central em diversas áreas do conhecimento, especialmente na engenharia,
onde profissionais precisam constantemente tomar decisões fundamentadas em critérios de
eficiência, viabilidade técnica e limitações físicas ou econômicas.
Engenheiros, por exemplo, enfrentam frequentemente problemas que exigem encontrar
as melhores dimensões para uma estrutura, minimizar o consumo de energia em um sistema,
ou maximizar a produtividade de um processo industrial. Esses desafios envolvem equilibrar
múltiplas variáveis e restrições, o que torna o uso de técnicas de otimização essencial para
a obtenção de soluções viáveis e eficazes.
Do ponto de vista matemático, a otimização está intimamente relacionada à localização
de raízes de funções (Capítulo 12), pois ambos os problemas envolvem a busca por valores
específicos associados ao comportamento de uma função. Enquanto a localização de raízes
se concentra em determinar os pontos onde a função se anula (ou seja, onde f (x) = 0), a
otimização busca identificar os pontos onde a função atinge valores extremos: os máximos
ou mínimos, locais ou globais.
A identificação desses extremos está diretamente relacionada à análise da derivada da
função. Por exemplo, os pontos críticos, onde a derivada primeira se anula (f ′ (x) = 0),
são candidatos naturais a serem máximos ou mínimos. Por isso, métodos numéricos para
otimização muitas vezes compartilham fundamentos com os métodos para localização de
raízes, aproveitando estratégias semelhantes, como aproximações sucessivas, iterações e
análise de convergência.
Embora em alguns casos seja possível obter soluções analíticas para problemas de
otimização,especialmente quando as funções envolvidas são simples ou possuem propriedades
específicas, a grande maioria dos problemas práticos é muito complexa para ser resolvida
de forma exata. Nesses casos, recorre-se a técnicas computacionais baseadas em métodos
numéricos.
 160 Capítulo 13. Otimização

13.2 Busca da Razão Áurea

A Busca da Razão Áurea é um método numérico simples, eficiente e amplamente utilizado
para localizar o ponto ótimo (mínimo ou máximo) de uma função de uma única variável.
Sua abordagem é análoga ao método da bisseção, empregado na localização de raízes. No
entanto, há uma diferença fundamental: enquanto a bisseção divide o intervalo ao meio de
forma equidistante, a busca da razão áurea seleciona os pontos internos com base em uma
proporção fixa, a razão áurea, o que resulta em uma divisão otimizada do intervalo.
O procedimento inicia-se com duas aproximações iniciais, xi e xf , que definem um
intervalo fechado [xi , xf ] contendo um único ponto ótimo, sob a suposição de que a função
seja unimodal nesse intervalo, ou seja, que possua apenas um único extremo (mínimo
ou máximo). Em seguida, são calculados dois pontos internos, x1 e x2 , com base na
razão áurea φ, onde φ ≈ 1.618034. Para que os pontos x1 e x2 sejam simetricamente
posicionados dentro do intervalo [xi , xf ], a proporção utilizada para subdividir o intervalo
é dada por φ − 1 ≈ 0.618034.
Essa escolha estratégica permite que, a cada iteração, o intervalo de busca seja reduzido
de maneira eficiente, acelerando a convergência para a solução ótima.
A seguir, apresentamos a escolha dos pontos x1 e x2 com base na razão áurea d,
conforme definido na Equação 13.1.
√
5−1
d= (xf − xi ), x1 = xi + d, x 2 = xf − d (13.1)
2

Condição Busca Máximo Busca Mínimo

Se f (x1 ) > f (x2 ) xi = x2 e max = x1 xf = x1 e min = x2
Se f (x1 ) < f (x2 ) xf = x1 e max = x2 xi = x2 e min = x1

Tabela 13.1: Estratégia de atualização do intervalo.

Após calcular a função nos pontos intermediários x1 e x2 , dois casos podem ocorrer: (i)
f (x1 ) > f (x2 ) ou (ii) f (x1 ) < f (x2 ). A atualização do intervalo depende do objetivo (mínimo
ou máximo), conforme resumido na Tabela 13.1. O processo é repetido iterativamente,
com redução progressiva do intervalo, até que a diferença entre xi e xf atenda ao critério
de convergência.
Se f (x1 ) > f (x2 )
- Busca do mínimo: O intervalo à direita, entre x1 e xf pode ser eliminado,
pois não contém o ponto mínimo. Assim, atualizamos xf = x1 e consideramos
x2 como a melhor aproximação até o momento.
- Busca do máximo: O intervalo à esquerda, entre xi e x2 , pode ser eliminado,
pois não contém o ponto máximo. Dessa forma, atualizamos xi = x2 e passamos
a considerar x1 como a melhor aproximação.
Se f (x1 ) < f (x2 )
- Busca do mínimo: O intervalo à esquerda, entre xi e x2 pode ser descartado,
pois não contém o ponto mínimo. Assim, atualizamos xi = x2 e definimo x1
como a melhor aproximação.
- Busca do máximo: O intervalo à direita, entre x1 e xf , pode ser eliminado,
pois não contém o ponto máximo. Com isso, atualizamos xf = x1 e adotamos
x2 como a melhor aproximação.
13.2 Busca da Razão Áurea 161

f (x)

d = 55.623

1.2 x1 xi = 130
xf = 220
1 d = 55.623
xf x2 = 164.37
0.8 x1 = 185.62
x2
0.6

0.4

0.2
xi
x
130 164.37 185.62 220

f (x) f (x)

f (x1 ) f (x1 )

f (xf ) f (xf )

f (x2 ) Busca Mínimo f (x2 ) Busca Máximo

Se f (x1 ) > f (x2 ) Se f (x1 ) > f (x2 )
xf = x1 xi = x2
min = x2 max = x1
f (xi ) f (xi )
x x

f (x) f (x)

f (xi ) f (x2 ) f (xi ) f (x2 )

Busca Mínimo Busca Máximo
Se f (x1 ) < f (x2 ) Se f (x1 ) < f (x2 )
xi = x2 xf = x1
min = x1 max = x2

f (x1 ) f (x1 )

f (xf ) f (xf )

x x

Figura 13.1: Representação gráfica do método da Razão Áurea em uma função unidimensional.
162 Capítulo 13. Otimização

Exemplo: 5
Exemplo: Utilize o método da razão áurea para encontrar o máximo da Equação 13.2, considerando
os pontos iniciais xi = −2 e xf = 4. Realize os cálculos até a terceira iteração.

x2
f (x) = 2 ∗ sin(x) − (13.2)
10

Solução: Primeira iteração (i = 1): Temos xi = −2 e xf = 4. Aplicando as Equações 13.1:

√
5−1
d= (xf − xi ) = 0.6180 ∗ (4 − (−2)) = 3.7080
2
x1 = xi + d = −2 + 3.7080 = 1.7080
x2 = xf − d = 4 − 3.7080 = 0.2920

Calculamos os pontos f (x1 ) e f (x2 ):

1.70802
f (x1 ) = 2 ∗ sin(1.7080) − = 1.6895
10
2
0.2920
f (x2 ) = 2 ∗ sin(0.2920) − = 0.5672
10
Como f (x1 ) > f (x2 ) e desejamos encontrar o valor máximo da função, então atualizamos xi = x2
e definimos o ponto máximo da iteração como max = x1
Segunda iteração (i = 2): Temos xi = 0.2920 e xf = 4.
√
5−1
d= (xf − xi ) = 0.6180 ∗ (4 − 0.2920) = 2.2915
2
x1 = xi + d = 0.2920 + 2.2915 = 2.5835
x2 = xf − d = 4 − 2.2915 = 1.7085

Calculamos os pontos f (x1 ) e f (x2 ):

2.58352
f (x1 ) = 2 ∗ sin(2.5835) − = 0.3915
10
2
1.7085
f (x2 ) = 2 ∗ sin(1.7085) − = 1.6892
10
Como f (x1 ) < f (x2 ) e desejamos encontrar o valor máximo da função, então atualizamos xf = x1
e definimos o ponto máximo da iteração como max = x2
Terceira iteração (i = 3): Temos xi = 0.2920 e xf = 2.5835.
√
5−1
d= (xf − xi ) = 0.6180 ∗ (2.5835 − 0.2920) = 1.4161
2
x1 = xi + d = 0.2920 + 1.4161 = 1.7081
x2 = xf − d = 2.5835 − 1.4161 = 1.1674
1.70812
f (x1 ) = 2 ∗ sin(1.7081) − = 1.6894
10
2
1.1674
f (x2 ) = 2 ∗ sin(1.1674) − = 1.7032
10
Como f (x1 ) < f (x2 ) e desejamos encontrar o valor máximo da função, então atualizamos xf = x1
e definimos o ponto máximo da iteração como max = x2 = 1.1674.
Solução: max = 1.1674, sendo f (max) = 1.7032
 13.3 Interpolação Quadrática 163

13.3 Interpolação Quadrática

A interpolação quadrática aproveita a propriedade de que um polinômio de segundo grau
pode, frequentemente, fornecer uma excelente aproximação para o comportamento da
função f (x) na busca por um mínimo ou máximo. Esse método é particularmente útil em
problemas de otimização, pois permite estimar a posição do ponto ótimo com base em
poucos valores da função.
Assim como uma reta é unicamente determinada por dois pontos, um polinômio
quadrático é definido por três pontos distintos. Ao selecionar três pontos adequados (x0 , x1
e x2 ), é possível ajustar uma parábola que os conecta e, a partir dela, obter uma estimativa
para a localização do extremo da função. Esse vértice xq pode ser calculado por meio da
Equação 13.3:

f (x0 )(x21 − x22 ) + f (x1 )(x22 − x20 ) + f (x2 )(x20 − x21 )

xq = (13.3)
2f (x0 )(x1 − x2 ) + 2f (x1 )(x2 − x0 ) + 2f (x2 )(x0 − x1 )
onde x0 , x1 e x2 são aproximações iniciais e xq é o valor de x que corresponde ao máximo
valor da função quadrática ajustada às aproximações.
A escolha dos pontos x0 , x1 e x2 no método da interpolação quadrática é crucial para
garantir uma boa convergência para o mínimo ou máximo da função. Aqui estão algumas
estratégias para selecionar esses pontos:
• Busca do Mínimo: Os pontos x0 , x1 e x2 devem estar próximos do mínimo esperado
e dispostos de forma que o ponto central x1 corresponda ao menor valor da função
entre os três. Ou seja, deve-se garantir que: f (x1 ) < f (x0 ) e f (x1 ) < f (x2 ). Essa
configuração assegura que a parábola interpolada tenha um vértice que aponta para
o mínimo da função.
• Busca do Máximo: Os pontos x0 , x1 e x2 devem estar próximos do máximo e
dispostos de forma que o ponto central x1 corresponda ao maior valor da função
entre os três. Ou seja, deve-se garantir que: f (x1 ) > f (x0 ) e f (x1 ) > f (x2 ). Essa
configuração assegura que a parábola interpolada tenha um vértice que aponta para
o máximo da função.
A atualização dos pontos depende da posição de xq em relação aos pontos atuais:
• Se xq estiver entre x0 e x1 , os pontos são atualizados como: x2 = x1 e x1 = xq .
• Se xq estiver entre x1 e x2 , a atualização ocorre da seguinte forma: x0 = x1 e x1 = xq .
A Figura 13.2a ilustra a aplicação do método da interpolação quadrática para a
localização de um ponto máximo. No gráfico, a curva azul representa a função original,
enquanto a curva vermelha corresponde à função quadrática ajustada a partir de três
pontos distintos. Os três pontos utilizados na interpolação são destacados em laranja e
marcados como x0 = (260, −0.6089), x1 = (270, 0.1) e x2 = (315, −0.57861). A partir deles,
a parábola ajustada permite estimar o ponto de máximo, indicado pelo rótulo amarelo, em
xq = (290.8520, 1.07222).
A Figura 13.2b ilustra a aplicação do método da interpolação quadrática para a
localização de um ponto mínimo. No gráfico, a curva azul representa a função original,
enquanto a curva vermelha corresponde à função quadrática ajustada a partir de três
pontos distintos. Os três pontos utilizados na interpolação são destacados em laranja. A
partir deles, a parábola ajustada permite estimar o ponto de máximo, indicado pelo rótulo
amarelo, em xq = (238.6918, −0.72873).
 164 Capítulo 13. Otimização

f (x) xq = (290.8520, 1.07222)

1

0.5

x1 (270, 0.1)
x
240 250 260 270 280 290 300 310 320 330 340 350

−0.5
x0 (260, −0.6089) x2 (315, −0.57861)

−1

Função Original
−1.5 Função Quadrática

(a) Aplicação do método da interpolação quadrática para a localização de um ponto máximo.

f (x)
1
x2 (280, 0.85031)

0.5

x0 (210, 0.13255)
x
170 180 190 200 210 220 230 240 250 260 270 280 290 300 310

−0.5 x1 (230, −0.43224)

xq = (238.6918, −0.72873)
−1

Função Original
−1.5 Função Quadrática

(b) Aplicação do método da interpolação quadrática para a localização de um ponto mínimo.

f (x) 2
Função: 2 sin(x) − x10

2 x1 = 1

x0 = −4.2 x0 = 0 x
−5 −3 −2 1 2 3 4 5 6

x2 = −0.5

x1 = −2.5 −2

x2 = 4

−4

(c) Legenda da terceira figura.

Figura 13.2: Figura principal com três subfiguras organizadas em 3 linhas e 1 coluna.
13.3 Interpolação Quadrática 165

Exemplo: 6
Use a interpolação quadrática com aproximações iniciais x0 = 0, x1 = 1 e x2 = 4 para aproximar o
ponto de máximo da Equação 13.4.

x2
f (x) = 2 ∗ sin(x) − (13.4)
10
Solução: Os valores da função nas três aproximações são dados por:

x0 = 0 = f (x0 ) = 0
x1 = 1 = f (x1 ) = 1.5829
x2 = 4 = f (x2 ) = −3.1136

substutuindo na Equação 13.3, teremos:

0(12 − 42 ) + 1.5829(42 − 02 ) + (−3.1136)(02 − 12 )

xq = = 1.5055
2(0)(1 − 4) + 2(1.5829)(4 − 0) + 2(−3.1136)(0 − 1)
onde f (1.5055) = 1.7691. Uma vez que o valor da função para o novo ponto é maior do que para o
ponto intermediário (x1 ) e o novo valor de x está à direita do ponto intermediário, a aproximação
inferior (x0 ) é descartada. Portanto, para a próxima iteração temos:

x0 = 1 = f (x0 ) = 1.5829
x1 = 1.5055 = f (x1 ) = 1.7691
x2 = 4 = f (x2 ) = −3.1136

substutuindo na Equação 13.3, teremos:

1.5829(1.50552 − 42 ) + 1.7691(42 − 12 ) + (−3.1136)(12 − 1.50552 )

xq = = 1.4903
2(1.5829)(1.5055 − 4) + 2(1.7691)(4 − 1) + 2(−3.1136)(1 − 1.5055)

o qual tem o valor da função de f (104903) = 1.7714. O processo pode ser repetido:

i x0 f (x0 ) x1 f (x1 ) x2 f (x2 ) xq f (xq )

1 0.0000 0.0000 1.0000 1.5829 4.0000 -3.1136 1.5055 1.7691
2 1.0000 1.5829 1.5055 1.7691 4.0000 -3.1136 1.4903 1.7714
3 1.0000 1.5829 1.4903 1.7714 1.5055 1.7691 1.4256 1.7757
4 1.0000 1.5829 1.4256 1.7757 1.4903 1.7714 1.4266 1.7757
5 1.4256 1.7757 1.4266 1.7757 1.4903 1.7714 1.4275 1.7757
166 Capítulo 13. Otimização

Eabs (t) Eabs (t) 0.00367071774715

0.25

0.2

0.15

0.1

0.0008617289

i i
5 10 15 20 3 5 10 15 20

(a) Evolução do erro absoluto ao longo de 20 (b) O método da interpolação quadrática

iterações na busca pelo ponto de mínimo. pode apresentar instabilidades.

Eabs (t) Eabs (t) 0.11090975969695

0.1

0.07244822123541

i i
5 10 15 20 3 5 10 15 20

(c) Evolução do erro absoluto ao longo de 20 (d) Observe a instabilidade do método ao

iterações na busca pelo ponto de máximo. longo das iterações.

Figura 13.3: Evolução do erro absoluto ao longo de 20 iterações. As subfiguras (a) e (b)
ilustram a aplicação do método para localização do mínimo (Figura 13.2c), enquanto as
subfiguras (c) e (d) mostram sua aplicação para a localização do máximo (Figura 13.2c).
Observe que o método da interpolação quadrática pode apresentar instabilidades ao longo
das iterações.

.
13.3 Interpolação Quadrática 167

Exemplo: 1
Métodos Numéricos para Engenharia, Chapra, 5th edição.

Questão 13.8: A trajetória de uma bola pode ser calculada pela Equação 13.5, onde y é a altura
(m), θ0 é o ângulo inicial (radianos), v0 é a velocidade inicial (m/s), g = 9.18 m/s2 é a aceleração
da gravidade e y0 é a altura inicial (m). Use a busca da razão áurea para determinar a altura
máxima, dados y0 = 1 m, v0 = 25 m/s e θ0 = 50o . Use a aproximação inicial de xi = 0 e xf = 60
metros.

g
y = (tan θ0 )x − x2 + y0 (13.5)
2v02 cos2 θ0

Solução:

No primeiro passo, escolha os pontos interiores como (xi + d) e (xf − d), onde:

√
5−1
d= (60 − 0) = 37.082.
2
x1 = xi + d = 0 + 37.082 = 37.082
x2 = xf − d = 60 − 37.082 = 22.918

Em seguida, aplicamos a Equação 13.5 e calculamos f (x1 ) e f (x2 ):

50π 9.81
 
f (x) = tan x−
x2 + 1
180 2 · 625 · cos2 50π
180 x
f (x1 ) = 19.074
f (x2 ) = 18.3361

Como (f (x1 ) > f (x2 )), definimos o limite inferior na próxima iteração como: xi = x2 . Lembrando:
Para converter um ângulo de graus para radianos, usamos a seguinte fórmula geral:

π
θrad = θgraus × (13.6)
180
Os resultados são fornecidos na tabela abaixo. Realize as iterações até que a precisão necessária
seja obtida.

i xi f(xi) x2 f(x2) x1 f(x1) xf f(xf) d

-------------------------------------------------------------------------------------------
1 0 1 22.9180 18.3361 37.0820 19.0740 60 4.12560 37.0820
2 22.9180 18.3361 37.0820 19.0740 45.8359 15.7193 60 4.12560 22.9180
3 22.9180 18.3361 31.6718 19.6917 37.0820 19.0740 45.8359 15.7193 14.1641
4 22.9180 18.3361 28.3282 19.5175 31.6718 19.6917 37.0820 19.0740 8.75390
5 28.3282 19.5175 31.6718 19.6917 33.7384 19.5870 37.0820 19.0740 5.41020
6 28.3282 19.5175 30.3947 19.6753 31.6718 19.6917 33.7384 19.5870 3.34370
7 30.3947 19.6753 31.6718 19.6917 32.4612 19.6709 33.7384 19.5870 2.06650
8 30.3947 19.6753 31.1840 19.6928 31.6718 19.6917 32.4612 19.6709 1.27720
9 30.3947 19.6753 30.8825 19.6889 [31.1840] [19.6920] 31.6718 19.6917 0.78930
-------------------------------------------------------------------------------------------

Resultado:

A altura máxima, y ≈ 19.6920m, é alcançada em x ≈ 31.1840.

168 Capítulo 13. Otimização

Exemplo: 2
Métodos Numéricos para Engenharia, Chapra, 5th.

Questão 13.9: A deflexão de uma viga uniforme submetida a uma carga crescente e linearmente
distribuída pode ser escrita pela Equação 13.7, onde L = 600 cm, E = 50000 kN/cm2 , I = 30000
cm4 e w0 = 2.5 kN/cm. Calcule o ponto de máxima deflexão. Use a busca da razão áurea com
aproximações iniciais xi = 0 e xf = L.

w0
y= (−x5 + 2L2 x3 − L4 x) (13.7)
120EIL
Solução:

Podemos realizar uma análise gráfica da função e observar que a deflexão máxima ocorre no ponto
mínimo da Equação 13.7. Em seguida, aplicamos o método da razão áurea para determinar esse
mínimo.

100 200 300 400 500 600

−0.2

−0.4

√
5−1
d= (600 − 0) = 370.82.
2
x1 = xi + d = 0 + 37.082 = 370.82
x2 = xf − d = 60 − 37.082 = 229.18
2.5
f (x1 ) = · −x5 + 2 · 6002 · x3 − 6004 · x = −0.42492


120 · 50000 · 30000 · 600
2.5
f (x2 ) = · −x5 + 2 · 6002 · x3 − 6004 · x = −0.50155


120 · 50000 · 30000 · 600
Como (f (x2 ) < f (x1 )), defina o limite superior na próxima iteração como xu = x1 . Os resultados
são fornecidos na tabela abaixo.

i xi f(xi) x2 f(x2) x1 f(x1) xf f(xf) d

------------------------------------------------------------------------------------
1 0 0 229.18 -0.5015 370.82 -0.4249 600 0 370.820
2 0 0 141.64 -0.3789 229.18 -0.5016 370.82 -0.4249 229.180
3 141.64 -0.3789 229.18 -0.5016 283.28 -0.5132 370.82 -0.4249 141.640
4 229.18 -0.5016 283.28 -0.5132 316.72 -0.4944 370.82 -0.4249 87.5388
5 229.18 -0.5016 262.62 -0.5149 283.28 -0.5132 316.72 -0.4944 54.1020
6 229.18 -0.5016 249.85 -0.5121 262.62 -0.5149 283.28 -0.5132 33.4369
7 249.85 -0.5121 262.62 -0.5149 270.51 -0.5151 283.28 -0.5132 20.6651
8 262.62 -0.5149 270.51 -0.5151 275.39 -0.5147 283.28 -0.5132 12.7717
9 262.62 -0.5149 267.5 -0.5152 270.51 -0.5151 275.39 -0.5147 7.89340
10 262.62 -0.5149 265.63 -0.5151 267.5 -0.5152 270.51 -0.5151 4.87840
------------------------------------------------------------------------------------

Resultado:

A máxima deflexão, y ≈ −0.52, é alcançada em x ≈ 267.5cm.

 13.3 Interpolação Quadrática 169

Folha de Exercício 28: [Solução da Folha de Exercício 28]

a) Busca da razão áurea (xi = 0, xf = 3) até erro absoluto

1. Empregue os seguintes métodos para encontrar o máximo
inferior a 0.000001.
de f (x) = −2x4 + 12x − 11.3906. Considere como refe-
b) Interpolação quadrática (x0 = 0, x1 = 1.5, x2 = 3) até
rência o ponto de máximo local em aproximadamente:
erro absoluto inferior a 0.000001.
(1.14471424304867, −1.08817181702001).
c) Gere um gráfico mostrando a evolução do erro abso-
a) Determine o valor de x que maximiza a função uti-
luto ao longo das iterações e analise se os algoritmos
lizando o método da busca da razão áurea xi = 0 e
apresentaram alguma instabilidade.
xf = 2. O cálculo deve ser realizado até que o erro
absoluto seja inferior a 0.0002. 6. Empregue os seguintes métodos para encontrar o máximo
b) Calcule o valor de x que maximiza a função utilizando de f (x) = xe−0.5x . Considere como referência o ponto de
a interpolação quadrática adotando as aproximações máximo local em aproximadamente: (2, 0.73576).
iniciais x0 = 0, x1 = 1 e x2 = 2. O cálculo deve ser a) Busca da razão áurea (xi = 0, xf = 5) até erro absoluto
realizado até que o erro absoluto seja inferior a 0.01. inferior a 0.0001.
c) Gere um gráfico mostrando a evolução do erro abso- b) Interpolação quadrática (x0 = 0, x1 = 2, x2 = 5) até
luto ao longo das iterações e analise se os algoritmos erro absoluto inferior a 0.0001.
apresentaram alguma instabilidade. c) Gere um gráfico mostrando a evolução do erro abso-
luto ao longo das iterações e analise se os algoritmos
2. Empregue os seguintes métodos para encontrar o má- apresentaram alguma instabilidade.
ximo de f (x) = xe−x . Considere como referên-
cia o ponto de máximo local em aproximadamente: 7. Empregue os seguintes métodos para encontrar o máximo de
2
(1.74568250406956, 1.71923501500295). f (x) = e−x . Considere como referência o ponto de máximo
a) Busca da razão áurea (xi = −2 e xf = 4). O cálculo local em aproximadamente: (0, 1).
deve ser realizado até que o erro absoluto seja inferior a) Busca da razão áurea (xi = −2, xf = 2) até erro abso-
a 0.00001. luto inferior a 0.000001.
b) Interpolação quadrática (x1 = 1.75, x2 = 2, x3 = 2.5). b) Interpolação quadrática (x0 = −1, x1 = 0, x2 = 1) até
O cálculo deve ser realizado até que o erro absoluto erro absoluto inferior a 0.000001.
seja inferior a 0.00001. c) Gere um gráfico mostrando a evolução do erro abso-
c) Gere um gráfico mostrando a evolução do erro abso- luto ao longo das iterações e analise se os algoritmos
luto ao longo das iterações e analise se os algoritmos apresentaram alguma instabilidade.
apresentaram alguma instabilidade.
8. Empregue os seguintes métodos para encontrar o máximo
3. Empregue os seguintes métodos para encontrar o máximo de f (x) = −(x − 3)2 + 9. Considere como referência o ponto
de f (x) = −x2 + 4x + 1. Considere como referência o ponto de máximo local em aproximadamente: (3, 9).
de máximo local em aproximadamente: (2, 5). a) Busca da razão áurea (xi = 1, xf = 5) até erro absoluto
a) Determine o valor de x que maximiza a função uti- inferior a 0.00001.
lizando o método da busca da razão áurea xi = 0 e b) Interpolação quadrática (x0 = 1, x1 = 3, x2 = 5) até
xf = 4. O cálculo deve ser realizado até que o erro erro absoluto inferior a 0.00001.
absoluto seja inferior a 0.0001. c) Gere um gráfico mostrando a evolução do erro abso-
b) Calcule o valor de x que maximiza a função utilizando luto ao longo das iterações e analise se os algoritmos
a interpolação quadrática adotando as aproximações apresentaram alguma instabilidade.
iniciais x0 = 0, x1 = 2 e x2 = 4. O cálculo deve ser
9. Empregue os seguintes métodos para encontrar o máximo
realizado até que o erro absoluto seja inferior a 0.0001.
de f (x) = x3 e−x . Considere como referência o ponto de
c) Gere um gráfico mostrando a evolução do erro abso-
máximo local em aproximadamente: (3, 1.344).
luto ao longo das iterações e analise se os algoritmos
a) Busca da razão áurea (xi = 0, xf = 6) até erro absoluto
apresentaram alguma instabilidade.
inferior a 0.00001.
4. Empregue os seguintes métodos para encontrar o máximo b) Interpolação quadrática (x0 = 1, x1 = 3, x2 = 5) até
de f (x) = ln(x) − x2 . Considere como referência o ponto de erro absoluto inferior a 0.00001.
máximo local em aproximadamente: (2, −0.30685). c) Gere um gráfico mostrando a evolução do erro abso-
a) Busca da razão áurea (xi = 0.1, xf = 5) até erro abso- luto ao longo das iterações e analise se os algoritmos
luto inferior a 0.00001. apresentaram alguma instabilidade.
b) Interpolação quadrática (x0 = 1, x1 = 2.5, x2 = 4) até
10. Empregue os seguintes métodos para encontrar o máximo
erro absoluto inferior a 0.00001.
de f (x) = x2 e−x . Considere como referência o ponto de
c) Gere um gráfico mostrando a evolução do erro abso-
máximo local em aproximadamente: (2, 0.5413).
luto ao longo das iterações e analise se os algoritmos
a) Busca da razão áurea (xi = 0, xf = 5).
apresentaram alguma instabilidade.
b) Interpolação quadrática (x0 = 0, x1 = 2, x2 = 4).
5. Empregue os seguintes métodos para encontrar o máximo c) Gere um gráfico mostrando a evolução do erro abso-
de f (x) = sin(x). Considere como referência o ponto

de luto e analise se os algoritmos apresentaram alguma
máximo local em aproximadamente: π2 ≈ 1.5708, 1 . instabilidade.
 170 Capítulo 13. Otimização

Folha de Exercício 29: [Solução da Folha de Exercício 29]

1. Empregue os seguintes métodos para encontrar o máximo de 6. Empregue os seguintes métodos para encontrar o máximo de
f (x) = 1+x
x
2 . Considere como referência o ponto de máximo f (x) = −2(x − 1)2 + 5. Considere como referência o ponto
local em aproximadamente: (1, 0.5). de máximo local em aproximadamente: (1, 5).
a) Busca da razão áurea (xi = 0, xf = 3) até erro absoluto a) Busca da razão áurea (xi = −1, xf = 3) até erro abso-
inferior a 0.00001. luto inferior a 0.0001.
b) Interpolação quadrática (x0 = 0, x1 = 1, x2 = 2) até b) Interpolação quadrática (x0 = −1, x1 = 1, x2 = 3) até
erro absoluto inferior a 0.00001. erro absoluto inferior a 0.0001.
c) Gere um gráfico mostrando a evolução do erro abso- c) Gere um gráfico mostrando a evolução do erro abso-
luto ao longo das iterações e analise se os algoritmos luto ao longo das iterações e analise se os algoritmos
apresentaram alguma instabilidade. apresentaram alguma instabilidade.
2. Empregue os √ seguintes métodos para encontrar o máximo 7. Empregue os seguintes métodos para encontrar o máximo
de f (x) = x 4 − x2 . Considere como referência
√ o ponto

de de f (x) = 3x2 e−x . Considere como referência o ponto de
máximo local em aproximadamente: 2 ≈ 1.4142, 2 . máximo local em aproximadamente: (2, 1.624).
a) Busca da razão áurea (xi = 0.5, xf = 2) até erro abso- a) Busca da razão áurea (xi = 0, xf = 6) até erro absoluto
luto inferior a 0.000001. inferior a 0.00001.
b) Interpolação quadrática (x0 = 0.5, x1 = 1, x2 = 2) até b) Interpolação quadrática (x0 = 1, x1 = 2, x2 = 4) até
erro absoluto inferior a 0.000001. erro absoluto inferior a 0.00001.
c) Gere um gráfico mostrando a evolução do erro abso- c) Gere um gráfico mostrando a evolução do erro abso-
luto ao longo das iterações e analise se os algoritmos luto ao longo das iterações e analise se os algoritmos
apresentaram alguma instabilidade. apresentaram alguma instabilidade.
3. Empregue os seguintes métodos para encontrar o máximo de 8. Empregue os seguintes métodos para encontrar o máximo
f (x) = −(x − 2)4 + 16. Considere como referência o ponto de f (x) = x4 e−x . Considere como referência o ponto de
de máximo local em aproximadamente: (2, 16). máximo local em aproximadamente: (4, 4.692).
a) Busca da razão áurea (xi = 0, xf = 4) até erro absoluto a) Busca da razão áurea (xi = 0, xf = 8) até erro absoluto
inferior a 0.0001. inferior a 0.00001.
b) Interpolação quadrática (x0 = 0, x1 = 2, x2 = 4) até b) Interpolação quadrática (x0 = 2, x1 = 4, x2 = 6) até
erro absoluto inferior a 0.0001. erro absoluto inferior a 0.00001.
c) Gere um gráfico mostrando a evolução do erro abso- c) Gere um gráfico mostrando a evolução do erro abso-
luto ao longo das iterações e analise se os algoritmos luto ao longo das iterações e analise se os algoritmos
apresentaram alguma instabilidade. apresentaram alguma instabilidade.
4. Empregue os seguintes métodos para encontrar o máximo de 9. Empregue os seguintes métodos para encontrar o máximo
f (x) = −3x2 + 12x − 5. Considere como referência o ponto de f (x) = sin(x) − 0.1 x. Considere como referência o ponto
de máximo local em aproximadamente: (2, 7). de máximo local em aproximadamente: (1.4706, 0.848).
a) Busca da razão áurea (xi = 0, xf = 5) até erro absoluto a) Busca da razão áurea (xi = 0, xf = 3.14) até erro ab-
inferior a 0.00001. soluto inferior a 0.00001.
b) Interpolação quadrática (x0 = 0, x1 = 2, x2 = 5) até b) Interpolação quadrática (x0 = 0, x1 = 1.5, x2 = 3) até
erro absoluto inferior a 0.00001. erro absoluto inferior a 0.00001.
c) Gere um gráfico mostrando a evolução do erro abso- c) Gere um gráfico mostrando a evolução do erro abso-
luto ao longo das iterações e analise se os algoritmos luto ao longo das iterações e analise se os algoritmos
apresentaram alguma instabilidade. apresentaram alguma instabilidade.
5. Empregue os seguintes métodos para encontrar o máximo 10. Empregue os seguintes métodos para encontrar o máximo
de f (x) = −x2 + 8x − 10. Considere como referência o ponto de f (x) = −x3 + 6x2 − 9x + 5. Considere como referência o
de máximo local em aproximadamente: (4, 6). ponto de máximo local em aproximadamente: (3, 5).
a) Busca da razão áurea (xi = 0, xf = 8) até erro absoluto a) Busca da razão áurea (xi = 0, xf = 5) até erro absoluto
inferior a 0.00001. inferior a 0.00001.
b) Interpolação quadrática (x0 = 0, x1 = 4, x2 = 8) até b) Interpolação quadrática (x0 = 0, x1 = 3, x2 = 5) até
erro absoluto inferior a 0.0001. erro absoluto inferior a 0.00001.
c) Gere um gráfico mostrando a evolução do erro abso- c) Gere um gráfico mostrando a evolução do erro abso-
luto ao longo das iterações e analise se os algoritmos luto ao longo das iterações e analise se os algoritmos
apresentaram alguma instabilidade. apresentaram alguma instabilidade.
 13.3 Interpolação Quadrática 171

Folha de Exercício 30: [Solução da Folha de Exercício 30]

1. A potência entregue por um gerador fotovoltaico em função 8. A relação sinal-ruído de um circuito pode ser modelada pela
da irradiância G (W/m2 ) pode ser aproximada pela Equa- Equação 13.15, onde d (dB) é o nível de atenuação. Use a
ção 13.8. Use a busca da razão áurea com aproximações busca da razão áurea com aproximações iniciais di = 0 dB e
iniciais Gi = 0 e Gf = 2000 para determinar o valor de G df = 50 dB para determinar d que maximiza S(d).
que maximiza P (G).
S(d) = d e−0.1 d (13.15)
−0.002 G
P (G) = G e (13.8)
9. A eficiência aerodinâmica de um perfil em função do coefici-
2. A eficiência volumétrica de uma bomba centrífuga em fun- ente de curvatura x pode ser aproximada pela Equação 13.16.
ção da velocidade angular ω (rad/s) pode ser estimada pela Use a busca da razão áurea com aproximações iniciais xi = 0
Equação 13.9. Use a busca da razão áurea com aproximações e xf = 5 para determinar x que maximiza f (x).
iniciais ωi = 0 e ωf = 10 para determinar ω que maximiza x
f (x) = (13.16)
η(ω). 1 + x2
ω
η(ω) = (13.9) 10. O consumo de combustível por distância v (m/s) pode ser
1 + ω2
aproximado pela Equação 13.17. Use a busca da razão áurea
3. A potência dissipada num resistor de carga R ligado a com aproximações iniciais vi = 0.1 m/s e vf = 50 m/s para
uma fonte de tensão V = 100 V com resistência interna determinar v que minimiza D(v).
Rint = 50 Ω é dada pela Equação 13.10. Use a busca da 10
razão áurea com aproximações iniciais Ri = 0 Ω e Rf = 200 D(v) = 0.1 v 2 + (13.17)
v
Ω para determinar o valor de R que maximiza P (R).
11. A amplitude de ressonância de um sistema massa-mola-
1002 R amortecedor, em função da frequência ω, é dada pela Equa-
P (R) = (13.10)
ção 13.18. Use a busca da razão áurea com aproximações

2
R + 50
iniciais ωi = 0 rad/s e ωf = 3 rad/s para determinar ω que
maximiza A(ω).
4. O custo total (em unidades monetárias) de uma tubulação
de diâmetro D (cm) pode ser modelado pela Equação 13.11. 1
A(ω) = p (13.18)
Use a busca da razão áurea com aproximações iniciais Di = 1 (1 − ω 2 )2 + (0.2 ω)2
cm e Df = 50 cm para determinar o valor de D que minimiza
C(D). 12. A função de ganho de um amplificador em função do fator
10000 x é dada pela Equação 13.19. Use a busca da razão áurea
C(D) = 200 D + (13.11) com aproximações iniciais xi = 1 e xf = 10 para determinar
D2
x que maximiza G(x).
5. O rendimento de uma reação química em função da tempe- x
ratura T (°C) pode ser aproximado pela Equação 13.12. Use G(x) = ln(x) − (13.19)
5
a busca da razão áurea com aproximações iniciais Ti = 0 °C
e Tf = 50 °C para determinar T que maximiza Y (T ). 13. A taxa de produção de um sistema em função do tempo t
(h) pode ser aproximada pela Equação 13.20. Use a busca
Y (T ) = T 2 e−T /10 (13.12) da razão áurea com aproximações iniciais ti = 0 h e tf = 50
h para determinar t que maximiza R(t).
6. A transferência de calor por convecção em um trocador
R(t) = t3 e−t/5 (13.20)
de calor de comprimento L (m) pode ser modelada pela
Equação 13.13. Use a busca da razão áurea com aproxima-
ções iniciais Li = 0 m e Lf = 30 m para determinar L que 14. A eficiência térmica de uma placa em função da espessura
maximiza Q(L). x (mm) pode ser modelada pela Equação 13.21. Use a
busca da razão áurea com aproximações iniciais xi = 0 mm
Q(L) = L e−L/5 (13.13) e xf = 100 mm para determinar x que maximiza H(x).
√
H(x) = x e−x/20 (13.21)
7. A eficiência de um aerogerador em função da velocidade
do vento v (m/s) pode ser aproximada pela Equação 13.14.
Use a busca da razão áurea com aproximações iniciais vi = 0 15. A Equação 13.22 descreve a variação de amplitude de um
m/s e vf = 150 m/s para determinar v que maximiza A(v). sinal amortecido. Use a busca da razão áurea com aproxima-
ções iniciais xi = 0 e xf = 4 para determinar x que maximiza
A(v) = v e−0.01 v (13.14) f (x).

f (x) = sin(x) − 0.05 x (13.22)

 14. Interpolação

14.1 Fundamentos
Muitas vezes, ao dispor de um conjunto de dados ou
pontos, surge a questão de saber se é possível mo- Tempo Temperatura
delar uma curva que represente o comportamento em minutos em C o
dessa distribuição e passe por todos os pontos. A
interpolação estuda métodos para construir tais 0 80
curvas, garantindo que essas condições sejam satis- 2 ?
feitas. 5 64
Muitas funções são conhecidas apenas em um 10 52
conjunto finito e discreto de pontos dentro de um 15 44
intervalo [a, b]. Um exemplo clássico é a tabela 20 38
que relaciona o calor específico da água com a 25 33
temperatura. 30 30
Imagine que você está testando um novo ma- 35 28
terial para fabricar xícaras de café. Um estagiário 40 25
registrou, a cada 5 minutos, a temperatura do café 45 25
após ser servido na xícara. Qual seria a tempera-
tura do café após 2 minutos do início do processo? Tabela 14.1: Temp. do café.
A interpolação auxilia na resolução desse tipo de
problema, bem como em situações em que possuí-
mos um conjunto de valores obtidos por meio de experimentos.
Interpolar uma função f (x) consiste em aproximar essa função por uma outra função
g(x), escolhida entre uma classe de funções definida a priori e que satisfaça algumas
propriedades. A função g(x) é então usada em substituição à função f (x).
A necessidade dessa substituição surge em diversas situações, tais como:
• Quando apenas os valores numéricos da função são conhecidos em um conjunto de
pontos, sem a sua forma analítica, e é necessário calcular o valor da função em um
ponto não tabelado.
• Quando a função em estudo possui uma expressão cuja diferenciação e integração
são complexas ou inviáveis. Nesses casos, pode-se buscar uma função aproximada
 174 Capítulo 14. Interpolação

que seja mais simples de manipular.

14.2 Operador de Diferenças Divididas

O estudo do operador de diferenças divididas é fundamental em várias áreas da matemática
e computação, especialmente em interpolação e na análise numérica de funções. Esse
método é amplamente utilizado para calcular o coeficiente angular que descrevem
a variação de uma função ou sequência de pontos, sendo essencial, principalmente, na
interpolação polinomial.
Considerando um conjunto de pontos yi = f (xi ) as diferenças divididas fornecem uma
abordagem eficiente para construir um polinômio interpolador que passa por todos esses
pontos. Os coeficientes angulares obtidos por esse método são de grande utilidade, pois
permitem determinar a forma do polinômio de interpolação sem a necessidade de resolver
sistemas de equações lineares complexos.
Seja f : R → R uma função tabelada em um subconjunto pontos de R, x0 , x1 , x2 , . . . , xk ,
formando k + 1 pontos. A diferença dividida de ordem 0 (zero) satisfaz a Equação 14.1:

f [x0 ] = f (x0 ) (14.1)

Essa notação estabelece uma convenção que será usada para construir diferenças
divididas de ordens superiores, mesmo que o valor da diferença dividida de ordem zero
coincida com o valor da função no ponto. Ou seja, o operador f [x0 ] representa, formalmente,
a aplicação do operador de diferenças divididas sobre um único nó, sendo por definição
idêntico à avaliação direta da função f em x0 .
Matematicamente, podemos considerar que a diferença dividida de ordem zero fornece
a base da estrutura triangular utilizada no algoritmo de Newton para interpolação, e serve
como ponto de partida para a construção de coeficientes mais complexos. Essa formalização
é importante porque permite descrever a interpolação de forma sistemática e recursiva,
mesmo nos casos em que se começa apenas com os valores pontuais da função.

14.3 Operador de Diferenças Divididas de Ordem 1 (ODD-1)

Dada uma função f (x) e dois pontos distintos da abscissa, x0 e x1 , com as respectivas
imagens y0 = f (x0 ) e y1 = f (x1 ), a diferença dividida de primeira ordem, também chamada
de diferença dividida de ordem 1, fornece uma medida da taxa média de variação da
função entre esses dois pontos. Essa taxa é representada por f [x1 , x0 ] e corresponde
geometricamente à inclinação da reta secante que liga os pontos (x0 , f (x0 )) e (x1 , f (x1 ))
no gráfico da função (Figura 14.5). Em termos geométricos, a inclinação da reta secante
entre os dois pontos pode ser interpretada como uma aproximação da derivada da função
no intervalo [x0 , x1 ], refletindo o comportamento da função nesse trecho.
1 Para a Diferença Dividade de Ordem 0, temos os valores da função nos pontos x0 e
x1 , ou seja, f [x0 ] = y0 e f [x1 ] = y1 .

f [x0 ] = f (x0 ) = y0

f [x1 ] = f (x1 ) = y1
14.3 Operador de Diferenças Divididas de Ordem 1 (ODD-1) 175

y
1.5

B
A = (x0 , f (x0 ))
1 B = (x1 , f (x1 ))
∆y
∆y m= ∆x

0.5

A
∆x
x
100 120 140 160 180 200 220 240 260

Figura 14.1: Representação geométrica das diferenças divididas de ordem zero e primeira.
O ponto (x0 , f (x0 )) representa a avaliação da função (ordem zero), enquanto a reta
secante entre (x0 , f (x0 )) e (x1 , f (x1 )) representa a diferença dividida de ordem um, dada
por f [x0 , x1 ].

2 O coeficiente angular (m) de uma reta secante entre dois pontos é dado pela razão
entre a variação em y e a variação em x, isto é, a diferença entre y0 e y1 dividida
pela diferença entre x0 e x1 .

Portanto, valor m representa a inclinação da reta que conecta (x0 , y0 ) e (x1 , y1 ), sendo
exatamente igual à diferença dividida de ordem 1, como descrito pela Equação 14.2:

∆y f [x1 ] − f [x0 ] f (x1 ) − f (x0 )

m= ou seja, f [x1 , x0 ] = = (14.2)
∆x x1 − x0 x1 − x0

Podemos também aplicar o processo de diferenças divididas de ordem 1 a outros pares

de pontos consecutivos, além de (x0 , y0 ) e (x1 , y1 ). Por exemplo, podemos calcular a
diferença dividida entre os pares (x1 , y1 ) e (x2 , y2 ), (x2 , y2 ) e (x3 , y3 ), e assim por diante.
De forma geral, o conceito se aplica a qualquer par de pontos consecutivos da forma (xk , yk )
e (xk+1 , yk+1 ), sendo definido pela fórmula:
 176 Capítulo 14. Interpolação

f [x2 ] − f [x1 ] f (x2 ) − f (x1 )

f [x2 , x1 ] = =
x2 − x1 x2 − x1
f [x3 ] − f [x2 ] f (x3 ) − f (x2 )
f [x3 , x2 ] = =
x3 − x2 x3 − x2
f [x4 ] − f [x3 ] f (x4 ) − f (x3 )
f [x4 , x3 ] = =
x4 − x3 x4 − x3
f [x5 ] − f [x4 ] f (x5 ) − f (x4 )
f [x5 , x4 ] = =
x5 − x4 x5 − x4
f [x6 ] − f [x5 ] f (x6 ) − f (x5 )
f [x6 , x5 ] = =
x6 − x5 x6 − x5
f [xk+1 ] − f [xk ] f (xk+1 ) − f (xk )
f [xk+1 , xk ] = =
xk+1 − xk xk+1 − xk

14.4 Operador de Diferenças Divididas de Ordem 2 (ODD-2)

A diferença dividida de ordem 2 mede a variação nas diferenças divididas de ordem
1 à medida que se percorrem três pontos consecutivos em uma tabela de valores. Em
outras palavras, ela expressa como a taxa média de variação da função está mudando de
um subintervalo para o próximo. Essa medida fornece uma estimativa da curvatura da
função nesse intervalo e indica o grau de não linearidade do comportamento da função
entre os pontos considerados.
Do ponto de vista geométrico, enquanto a diferença de primeira ordem se relaciona à
inclinação de retas secantes (isto é, à taxa de crescimento local da função), a diferença de
segunda ordem nos dá informações sobre a concavidade da curva. Valores positivos de
diferenças divididas de ordem 2 sugerem que a função está "curvando para cima" (côncava
para cima), enquanto valores negativos indicam "curvatura para baixo"(côncava para baixo).
Essa análise é especialmente útil na construção de polinômios interpoladores mais precisos
e na interpretação do comportamento da função em métodos numéricos.
Considere três pares de pontos, (x0 , y0 ), (x1 , y1 ) e (x2 , y2 ). A diferença dividida de
ordem 2, escrita como f [x2 , x1 , x0 ], é uma extensão do conceito de diferenças divididas
de ordem 1. Esse processo envolve calcular a diferença entre as diferenças divididas de
ordem 1 de dois intervalos consecutivos, f [x1 ] − f [x0 ] e f [x2 ] − f [x1 ], em seguida, dividir
essa diferença pela distância total entre os pontos extremos (x2 − x0 ). As Equações 14.3
e 14.4 descrevem esse conceito.

f [x2 ] − f [x1 ] f [x1 ] − f [x0 ]

−
f [x2 , x1 ] − f [x1 , x0 ] x2 − x1 x1 − x0
f [x2 , x1 , x0 ] = = (14.3)
x2 − x0 x2 − x0

f [x3 ] − f [x2 ] f [x2 ] − f [x1 ]

−
f [x3 , x2 ] − f [x2 , x1 ] x3 − x2 x2 − x1
f [x3 , x2 , x1 ] = = (14.4)
x3 − x1 x3 − x1
 14.5 Operador de Diferenças Divididas de Ordem 3 (ODD-3) 177

1.2
f (x)

(x0 , f (x0 ))
f [x1 , x0 ] 0.8

0.5
(x1 , f (x1 ))
f [x2 , x1 ]

(x2 , f (x2 )) 0.2

x
−0.95 −0.7 −0.5

Figura 14.2: Representação Geométrica da Diferença Dividida de Segunda Ordem

14.5 Operador de Diferenças Divididas de Ordem 3 (ODD-3)

O processo de cálculo da terceira diferença dividida é uma extensão do conceito de
diferenças divididas de primeira e segunda ordem. A diferença dividida de ordem 3
envolve quatro pontos distintos da tabela de valores da função: (x0 , y0 ), (x1 , y1 ), (x2 , y2 ) e
(x3 , y3 ). Sua definição está baseada na recursividade das fórmulas anteriores, utilizando as
diferenças divididas de ordem 2, que por sua vez dependem das diferenças divididas de
ordem 1. Nesse momento, é possível observar a natureza recursiva dos cálculos à medida
que aumentamos o grau das diferenças divididas. A expressão analítica da terceira diferença
dividida é apresentada na Equação 14.5, onde podemos visualizar claramente a hierarquia
dos cálculos:

f [x3 , x2 , x1 ] − f [x2 , x1 , x0 ]
f [x3 , x2 , x1 , x0 ] =
x3 − x0

f [x3 , x2 ] − f [x2 , x1 ] f [x2 , x1 ] − f [x1 , x0 ]

−
x3 − x1 x2 − x0
=
x3 − x0

f [x3 ] − f [x2 ] f [x2 ] − f [x1 ] f [x2 ] − f [x1 ] f [x1 ] − f [x0 ]

− −
x3 − x2 x2 − x1 x2 − x1 x1 − x0
−
x3 − x1 x2 − x0
=
x3 − x0
(14.5)
 178 Capítulo 14. Interpolação

f (x)
1.2

1
(x0 , f (x0 ))
f [x1 , x0 ]
0.8

(x1 , f (x1 ))
f [x2 , x1 ]
0.5

(x2 , f (x2 ))
f [x3 , x2 ]

0.2

(x3 , f (x3 ))
x
−1 −0.85 −0.65 −0.4

Figura 14.3: Representação Geométrica da Diferença Dividida de Terceira Ordem

14.6 Forma Geral da Diferença Dividida (ODD-m)

Se mais pontos forem fornecidos, o procedimento para calcular diferenças divididas de
ordens superiores continua da mesma maneira, aplicando a relação recursiva de diferenças
divididas sucessivamente. Esse método permite construir polinômios interpoladores de
forma eficiente, sendo particularmente útil na interpolação de Newton. A forma geral da
diferença divididas de ordem m é expressa pela Equação 14.6:

f [xm−1 , . . . , xi+1 , xi ] − f [xm , . . . , xi+2 , xi+1 ]

f [xm , xm−1 , . . . , xi+2 , xi+1 , xi ] = (14.6)
xm − xi

Essa equação representa uma generalização do conceito de diferenças divididas, onde

cada nova ordem de diferença dividida é calculada a partir das diferenças da ordem
imediatamente inferior. Esse processo reflete a estrutura hierárquica da interpolação de
Newton, garantindo que os coeficientes do polinômio sejam determinados de maneira
incremental e eficiente.
Para ilustrar melhor o conceito, as diferenças divididas de ordens 1 a 4 são apresentadas
nas Equações 14.7 a 14.10. Essas expressões demonstram como os valores da função são
combinados e subtraídos para gerar coeficientes intermediários, que posteriormente são
utilizados na construção do polinômio interpolador.
O procedimento de determinação dos coeficientes via diferenças divididas pode ser
organizado de forma sistemática por meio de uma tabela. Essa abordagem facilita a
visualização das operações realizadas e permite um cálculo estruturado dos coeficientes do
polinômio interpolador. A Tabela 14.2 apresenta um exemplo desse processo considerando
um conjunto de dados com três pontos, demonstrando a aplicação prática do método.
 14.7 Implementação da Diferença Dividida (Ordem m) 179

f [x1 ] − f [x0 ]
f [x1 , x0 ] = (14.7)
x1 − x0

f [x2 , x1 ] − f [x1 , x0 ]
f [x2 , x1 , x0 ] = (14.8)
x2 − x0

f [x3 , x2 , x1 ] − f [x2 , x1 , x0 ]
f [x3 , x2 , x1 , x0 ] = (14.9)
x3 − x0

f [x4 , x3 , x2 , x1 ] − f [x3 , x2 , x1 , x0 ]
f [x4 , x3 , x2 , x1 , x0 ] = (14.10)
x4 − x0

xi Ordem 0 Ordem 1 Ordem 2 Ordem 3 Ordem 4 Ordem 5

x0 f [x0 ]
x1 f [x1 ] f [x1 , x0 ]
x2 f [x2 ] f [x2 , x1 ] f [x2 , x1 , x0 ]
x3 f [x3 ] f [x3 , x2 ] f [x3 , x2 , x1 ] f [x3 , x2 , x1 , x0 ]
x4 f [x4 ] f [x4 , x3 ] f [x4 , x3 , x2 ] f [x4 , x3 , x2 , x1 ] f [x4 , x3 , x2 , x1 , x0 ]
x5 f [x5 ] f [x5 , x4 ] f [x5 , x4 , x3 ] f [x5 , x4 , x3 , x2 ] f [x5 , x4 , x3 , x2 , x1 ] f [x5 , x4 , x3 , x2 , x1 , x0 ]

Tabela 14.2: Tabela de diferenças divididas para um conjunto de dados com seis pontos.

14.7 Implementação da Diferença Dividida (Ordem m)

A implementação do cálculo das diferenças divididas segue uma abordagem matricial
que permite organizar os valores intermediários de maneira eficiente e sistemática. Essa
abordagem é particularmente útil para cálculos manuais organizados em tabela, bem como
para implementação computacional em algoritmos de interpolação. O método pode ser
descrito pelos seguintes passos:
1. Definição da matriz de diferenças divididas:
- Considere uma matriz D de dimensão n × n, onde n representa o número de pontos
da função tabulada. Essa matriz será utilizada para armazenar progressivamente
todas as diferenças divididas de ordens crescentes.
- Cada entrada D[i, j] armazenará a diferença dividida de ordem j, associada ao ponto
xi , ou seja, f [xi , xi−1 , . . . , xi−j ], desde que os índices estejam dentro dos limites da
matriz.
2. Armazenamento dos valores da função:
- Inicialmente, considera-se um vetor X contendo os valores do eixo x correspondentes
aos nós da função tabelada.
- A primeira coluna da matriz D, isto é, D[:, 0], será preenchida diretamente com
os valores conhecidos da função f (x) nos pontos xi . Essa coluna corresponde às
diferenças divididas de ordem zero:

D[i, 0] = f (xi ) para i = 0, 1, . . . , n − 1

3. Cálculo das diferenças divididas de ordens superiores:

 180 Capítulo 14. Interpolação

- As colunas seguintes da matriz D serão preenchidas de forma iterativa. Para cada

ordem j = 1, 2, . . . , n − 1, as diferenças divididas são calculadas utilizando a fórmula
recursiva:
D[i][j − 1] − D[i − 1][j − 1]
D[i][j] =
X[i] − X[i − j]
- O preenchimento é feito coluna por coluna, da esquerda para a direita, garantindo
que cada valor necessário esteja disponível no momento do cálculo.
- Note que a matriz D possui estrutura triangular inferior (quando disposta com
colunas diagonais crescentes), o que implica que apenas a metade superior ou inferior
da matriz é efetivamente preenchida.
O processo de preenchimento da matriz D pode ser automatizado por meio de um
algoritmo implementado em Python. O script [Link] executa os passos descritos
acima. O programa recebe como entrada os valores dos vetores X e Y = f (X) e retorna a
matriz completa contendo as diferenças divididas até a ordem máxima n − 1.
[Link]
1 import numpy
2 n = 3
3 D = [Link]((n,n))
4 X = [Link]([-1,1,2])
5 Y = [Link]([3,4,7])
6 D[:,0] = Y
7
8 for j in range(1,n,1):
9 for i in range(j,n):
10 D[i,j]= (D[i,j-1] - D[i-1,j-1]) / (X[i]-X[i-j])

14.8 Interpolação de Newton

A interpolação de Newton é um método numérico amplamente utilizado para estimar o
valor de uma função desconhecida com base em um conjunto discreto de pontos conhecidos.
Esse método se baseia na construção de um polinômio interpolador por meio da técnica
das diferenças divididas, permitindo aproximar valores intermediários de maneira eficiente.
O processo inicia-se com o cálculo das diferenças divididas, que fornecem uma medida
de como a função varia entre os pontos fornecidos. Com esses valores, o polinômio
interpolador de Newton é construído progressivamente, somando termos baseados nas
diferenças divididas. Para dois pontos x0 e x1 , o polinômio interpolador assume a forma:

p1 (x) = f [x0 ] + f [x1 , x0 ](x − x0 )

Se adicionarmos um terceiro ponto x2 , o polinômio interpolador se expande para:

p2 (x) = f [x0 ] + f [x1 , x0 ](x − x0 ) + f [x2 , x1 , x0 ](x − x0 )(x − x1 )

A notação p1 e p2 indica que esse é um polinômio interpolador de primeiro e segundo

grau, respectivamente. Em geral, quanto menor o intervalo entre os pontos dados, melhor
a aproximação, o que se deve ao fato de que, conforme o intervalo diminui, uma função
contínua será mais bem aproximada por uma reta.
De maneira geral, quando se deseja construir um polinômio interpolador que passe por
um conjunto de n + 1 pontos distintos (x0 , f (x0 )), (x1 , f (x1 )), . . . , (xn , f (xn )), utilizamos a
14.8 Interpolação de Newton 181

forma geral do polinômio interpolador de Newton com diferenças divididas. Esse polinômio
pode ser representado de forma compacta pela seguinte expressão:

n
X i−1
Y
pn (x) = f [x0 ] + f [xi , xi−1 , . . . , x0 ] (x − xj ) (14.11)
i=1 j=0

Cada termo adicionado ao polinômio aumenta seu grau e incorpora mais informações
sobre o comportamento da função. Essa estrutura permite construir o polinômio progressi-
vamente, sem necessidade de recalcular tudo ao incluir um novo ponto. A Equação 14.12
mostra a forma expandida da Equação 14.11, evidenciando a contribuição de cada termo
individualmente:

p(x) = f [x0 ]
+ f [x1 , x0 ](x − x0 )
+ f [x2 , x1 , x0 ](x − x0 )(x − x1 )
+ f [x3 , x2 , x1 , x0 ](x − x0 )(x − x1 )(x − x2 )
+ f [xn , . . . , x3 , x2 , x1 , x0 ](x − x0 )(x − x1 )(x − x2 ) . . . (x − xn ) (14.12)

Um aspecto importante é que o método de Newton não exige que os pontos estejam
igualmente espaçados, o que o torna bastante flexível. Além disso, as diferenças divididas
são calculadas de forma recursiva: cada diferença de ordem superior depende apenas das
de ordem imediatamente inferior.

A qualidade da aproximação depende da escolha dos pontos e do comportamento da

função original. Funções suaves e bem comportadas tendem a ser melhor representadas
por polinômios de menor grau, enquanto funções com variações bruscas podem exigir mais
termos para uma boa aproximação.
182 Capítulo 14. Interpolação

f (x)
0.4

0.2

x
−1.2 −1 −0.8 −0.6 −0.4 −0.2 0.2 0.4 0.6 0.8 1 1.2

−0.2

sin(5x)
f (x) = 1+25x2
−0.4
Pontos discretos
Função interpolada

sin(5x)
Figura 14.4: Comparação entre a função original f (x) = 1+25x 2 (linha azul), os pontos
discretos utilizados na interpolação de Newton (marcadores vermelhos) e a função
interpolada resultante (linha vermelha tracejada).

f (x)
0.4

0.2

x
−1.2 −1 −0.8 −0.6 −0.4 −0.2 0.2 0.4 0.6 0.8 1 1.2

−0.2

sin(5x)
f (x) = 1+25x2
−0.4
Pontos discretos
Erro absoluto

sin(5x)
Figura 14.5: Gráfico da função original f (x) = 1+25x 2 (linha azul), com os pontos discretos
usados na interpolação (pontos vermelhos) e a curva do erro absoluto (linha laranja
tracejada).
14.8 Interpolação de Newton 183

Provas Anteriores: 4
[Prova 2024.2] - Seja a função f (x) tabelada abaixo, Use o Polinômio Interpolador de Newton
para obter a aproximação em x = 0

x −2 −1 1 2
f (x) 1 0 −1 3

xi Ordem 0 Ordem 1 Ordem 2 Ordem 3

−2 f [x0 ]
−1 f [x1 ] f [x1 , x0 ]
1 f [x2 ] f [x2 , x1 ] f [x2 , x1 , x0 ]
2 f [x3 ] f [x3 , x2 ] f [x3 , x2 , x1 ] f [x3 , x2 , x1 , x0 ]

0−1 −1
f [x1 , x0 ] = = = −1
−1 − (−2) 1
−1 − 0 −1
f [x2 , x1 ] = = = −0.5
1 − (−1) 2
3 − (−1) 4
f [x3 , x2 ] = = =4
2−1 1
−0.5 − (−1) 0.5
f [x2 , x1 , x0 ] = = ≈ 0.1667
1 − (−2) 3
4 − (−0.5) 4.5
f [x3 , x2 , x1 ] = = = 1.5
2 − (−1) 3
1.5 − 0.1667 1.3333
f [x3 , x2 , x1 , x0 ] = = ≈ 0.3333
2 − (−2) 4
Assim, considerando x = 0 e aplicando a Equação 14.11 da forma geral do polinômio interpolador
de Newton:

p(x) = f [x0 ]
+ f [x1 , x0 ](x − x0 )
+ f [x2 , x1 , x0 ](x − x0 )(x − x1 )
+ f [x3 , x2 , x1 , x0 ](x − x0 )(x − x1 )(x − x2 )

p(x) = 1
+ −1(0 − (−2))
+ 0.1666(0 − (−2))(0 − (−1))
+ 0.3333(0 − (−2))(0 − (−1))(0 − 1)
≈ −1.3333 . . .

Finalmente, o ponto interpolado em x = 0 é −1.3333 . . .

 184 Capítulo 14. Interpolação

14.9 Interpolação de Lagrange

A interpolação de Lagrange é um método clássico de interpolação polinomial, amplamente
utilizado para estimar o valor de uma função f (x) com base em um conjunto discreto
de pontos conhecidos (x0 , y0 ), (x1 , y1 ), . . . , (xn , yn ), onde yi = f (xi ) para i = 0, 1, . . . , n. O
método consiste na construção de um polinômio P (x), de grau no máximo n, que satisfaz
a condição de interpolação:

P (xi ) = f (xi ) = yi , para i = 0, 1, . . . , n. (14.13)

Esse polinômio é expresso como uma combinação linear de funções base conhecidas como
polinômios de Lagrange, os quais são definidos de forma a valer 1 em um ponto xi e 0 nos
demais. Uma das principais vantagens do método de Lagrange é que ele fornece uma forma
fechada e direta para o polinômio interpolador, sem a necessidade de cálculo de diferenças
divididas, como ocorre no método de Newton.
Apesar de ser matematicamente elegante e conceitualmente simples, a interpolação de
Lagrange pode apresentar limitações práticas quando aplicada a um grande número de
pontos, especialmente se eles forem equidistantes, devido à possibilidade de surgimento de
oscilações indesejadas (fenômeno de Runge). Ainda assim, é uma ferramenta fundamental
na teoria da aproximação de funções e serve de base para diversos métodos numéricos mais
avançados.
O polinômio interpolador de Lagrange é uma combinação linear de funções base
projetadas especificamente para passar por um conjunto de pontos dados. Ele é definido
por:
n
X
P (x) = yi · Li (x) (14.14)
i=0

onde yi = f (xi ) são os valores da função nos pontos de interpolação, e Li (x) são os
polinômios básicos de Lagrange, responsáveis por construir a base da interpolação. Cada
Li (x) atua como um peso seletivo que isola o valor yi , assumindo o valor 1 no ponto xi
e 0 em todos os outros pontos xj com j ̸= i. Essa característica garante que o polinômio
interpolador passe exatamente por todos os pontos dados. A forma geral de cada Li (x) é
dada por:
n
Y x − xj
Li (x) = (14.15)
j=0
xi − xj
j̸=i

Cada polinômio Li (x) é construído de modo que assuma o valor 1 no ponto xi e zero
em todos os demais pontos xj , com j ̸= i. Em outras palavras:

1, se i = j
Li (xj ) = (14.16)
0, se i ̸= j

Essa propriedade garante que o polinômio interpolador P (x) satisfaça exatamente a

condição P (xi ) = yi para todos os i = 0, 1, . . . , n, ou seja, que ele passe por todos os pontos
dados. A construção evita o sistema linear associado à interpolação geral, oferecendo uma
forma explícita e direta, embora computacionalmente mais custosa para grandes conjuntos
de dados.
14.9 Interpolação de Lagrange 185

Vamos apresentar a forma expandida do polinômio interpolador de Lagrange consi-

derando um conjunto de quatro pontos distintos: (x0 , y0 ), (x1 , y1 ), (x2 , y2 ), (x3 , y3 ). Esse
polinômio pode ser construído de maneira explícita como uma combinação linear dos
polinômios básicos Li (x), cada um multiplicado pelo valor correspondente yi da função.
Cada polinômio básico Li (x) é definido de forma a satisfazer a condição Li (xj ) = δij ,
ou seja, vale 1 quando x = xi e 0 nos demais pontos xj com j ̸= i. Essa propriedade
garante que o polinômio interpolador P (x) assuma exatamente o valor yi quando x = xi ,
assegurando que o gráfico do polinômio passe pelos quatro pontos fornecidos.
A expressão geral do polinômio de Lagrange para esse caso é dada por:

P (x) = y0 · L0 (x) + y1 · L1 (x) + y2 · L2 (x) + y3 · L3 (x), (14.17)

onde cada Li (x) é um polinômio de grau três. Os polinômios básicos de Lagrange para os
quatro pontos são definidos por:

(x − x1 )(x − x2 )(x − x3 )
L0 (x) =
(x0 − x1 )(x0 − x2 )(x0 − x3 )
(x − x0 )(x − x2 )(x − x3 )
L1 (x) =
(x1 − x0 )(x1 − x2 )(x1 − x3 )
(x − x0 )(x − x1 )(x − x3 )
L2 (x) =
(x2 − x0 )(x2 − x1 )(x2 − x3 )
(x − x0 )(x − x1 )(x − x2 )
L3 (x) = (14.18)
(x3 − x0 )(x3 − x1 )(x3 − x2 )

Essas frações polinomiais garantem que, ao multiplicarmos cada Li (x) pelo respectivo
valor yi , o termo resultante contribua apenas na posição correta, construindo assim um
polinômio P (x) que satisfaz a condição de interpolar os dados.
Substituindo explicitamente os polinômios básicos na expressão geral, obtemos a forma
completa de P (x):

(x − x1 )(x − x2 )(x − x3 )
P (x) = y0 ·
(x0 − x1 )(x0 − x2 )(x0 − x3 )
(x − x0 )(x − x2 )(x − x3 )
+ y1 ·
(x1 − x0 )(x1 − x2 )(x1 − x3 )
(x − x0 )(x − x1 )(x − x3 )
+ y2 ·
(x2 − x0 )(x2 − x1 )(x2 − x3 )
(x − x0 )(x − x1 )(x − x2 )
+ y3 · (14.19)
(x3 − x0 )(x3 − x1 )(x3 − x2 )

Essa forma analítica permite não apenas estimar o valor de P (x) para qualquer ponto
x, mas também visualizar a contribuição de cada ponto original para o valor final do
polinômio. Além disso, o método de Lagrange tem a vantagem de ser fácil de implementar
e compreender, embora o cálculo do polinômio completo possa se tornar custoso para
grandes conjuntos de dados.
186 Capítulo 14. Interpolação

Provas Anteriores: 5
[Prova 2024.2] - Seja a função f (x) tabelada abaixo, Use o Polinômio Interpolador de Lagrange
para obter a aproximação em x = 0

x −2 −1 1 2
f (x) 1 0 −1 3

Solução: Aplicando aos pontos dados (−2, 1), (−1, 0), (1, −1), (2, 3), temos:

P (0) = f (−2) · L0 (0) + f (−1) · L1 (0) + f (1) · L2 (0) + f (2) · L3 (0)

Cálculo dos termos Li (0):

(0 − x1 )(0 − x2 )(0 − x3 ) 1 · (−1) · (−2) 2

L0 (0) = = = = −0.16666
(x0 − x1 )(x0 − x2 )(x0 − x3 ) (−1) · (−3) · (−4) −12

(0 − x0 )(0 − x2 )(0 − x3 ) 2 · (−1) · (−2) 4

L1 (0) = = = = 0.66666
(x1 − x0 )(x1 − x2 )(x1 − x3 ) 1 · (−2) · (−3) 6

(0 − x0 )(0 − x1 )(0 − x3 ) 2 · 1 · (−2) −4

L2 (0) = = = = 0.66666
(x2 − x0 )(x2 − x1 )(x2 − x3 ) 3 · 2 · (−1) −6

(0 − x0 )(0 − x1 )(0 − x2 ) 2 · 1 · (−1) −2

L3 (0) = = = = −0.16666
(x3 − x0 )(x3 − x1 )(x3 − x2 ) 4·3·1 12

Substituindo os valores de f (xi ):

P (0) = 1 · (−0.16666) + 0 · (0.66666) + (−1) · (0.66666) + 3 · (−0.16666)

= −0.16666 + 0 + (−0.66666) + (−0.5)

= −1.33333

Resposta final:

f (0) ≈ −1.33333
 14.9 Interpolação de Lagrange 187

Folha de Exercício 31: [Solução da Folha de Exercício 31]

1. Use o polinômio interpoladores de Newton para determinar 8. A temperatura no interior de uma parede foi registrada
y em x = 3.5 para a melhor precisão possível. Calcule as para diferentes profundidades. Estime a temperatura em
diferenças divididas finitas e ordene seus pontos para obter x = 7 cm.
acurácia e convergência ótimas; ou seja, os pontos devem
Profundidade (cm) 0 5 10
ser centrados em torno e tão próximo quanto possível do
valor desconhecido. Temperatura (◦ C) 28 23 18

9. O desgaste de uma peça foi medido após vários ciclos de uso.

x 0 1 2.5 3 4.5 5 6
Estime, via Newton, o desgaste após N = 400 ciclos.
y 2 5.4375 7.3516 7.5625 8.4453 9.1875 12
Ciclos 0 100 300 500
2. Use o polinômio interpoladores de Newton para determinar Desgaste (mm) 0,00 0,10 0,32 0,58
y em x = 8 para a melhor precisão possível. Calcule as
diferenças divididas finitas e ordene seus pontos para obter 10. O volume de gás dissolvido em um líquido foi medido em
acurácia e convergência ótimas; ou seja, os pontos devem diferentes pressões. Estime, via Newton, o volume dissolvido
ser centrados em torno e tão próximo quanto possível do em P = 2, 5 atm.
valor desconhecido.
Pressão (atm) 1 2 3
x 0 1 2 5.5 11 13 16 18
Volume (mL) 22 41 58
y 0.5 3.134 5.3 9.9 10.2 9.35 7.2 6.2

3. Você mediu a queda de tensão V através de um resistor para 11. Em uma análise de engenharia ambiental, a concentração
diversos valores diferentes de corrente i. Os resultados são de um gás poluente no ar foi medida em diferentes alturas.
mostrados na tabela abaixo. Use interpolação polinomial de Use o método de Newton para estimar a concentração em
quarto grau para fazer uma estimativa da queda de tensão h = 22 m e plote o gráfico do polinômio interpolador com os
para i = 1.15. pontos.

i 0.25 0.75 1.25 1.5 2.0 Altura (m) 10 20 30 40

3
V −0.45 −0.6 0.70 1.88 6.0 Concentração (mg/m ) 0,35 0,29 0,25 0,21

4. A aceleração da gravidade a uma altitude y acima da su- 12. O rendimento de uma reação enzimática foi tabelado para
perfície da Terra é dada na tabela abaixo. Calcule g em diferentes temperaturas. Use o polinômio de Lagrange para
y = 55000m. estimar o rendimento em T = 33◦ C e plote o gráfico.

y, m 0 30000 60000 90000 120000 Temperatura (◦ C) 20 30 40

g, m/s2 9.8100 9.7487 9.6879 9.6278 9.5682 Rendimento (%) 58 65 62

5. A economia de um carro (km/litro) varia com sua veloci- 13. Um sensor de pressão apresentou leituras em diferentes pro-
dade. Em um experimento, são feitas as cinco medições a fundidades. Use o método de Newton para estimar a pressão
seguir: para z = 3, 5 m e plote o gráfico do polinômio interpolador.

Velocidade (km/h) 16 40 64 88 112 Profundidade (m) 2 4 6

Economia (km/litro) 4.2 9.2 10 10.7 8.6 Pressão (kPa) 18 30 48

Calcule o polinômio interpolador de Newton de quarta ordem

14. Uma barra de alumínio foi aquecida e teve seu comprimento
para calcular a economia de combustível a 48km/h.
registrado em várias temperaturas. Use Lagrange para es-
6. O consumo de combustível de um automóvel foi regis- timar o comprimento para T = 160◦ C e plote o gráfico do
trado para diferentes velocidades. Estime o consumo a polinômio e dos dados originais.
v = 70 km/h.
Temperatura (◦ C) 20 80 140 200
Velocidade (km/h) 40 60 80
Comprimento (mm) 199,8 200,2 200,8 201,4
Consumo (L/100 km) 8,2 7,1 6,7
15. O tempo de reação de um catalisador foi registrado para
7. O pH de uma solução foi medido para diferentes concen- diferentes concentrações do reagente. Use o método de New-
trações de ácido. Estime, usando Newton, o pH para ton para estimar o tempo para C = 0, 35 mol/L e plote o
C = 0, 8 mol/L. gráfico do polinômio interpolador.

Concentração (mol/L) 0,1 0,5 1,0 Concentração (mol/L) 0,2 0,4 0,6
pH 1,0 0,5 0,0 Tempo (s) 75 51 39
 188 Capítulo 14. Interpolação

Folha de Exercício 32: [Solução da Folha de Exercício 32]

1. Uma ponte de aço sofre deformação térmica devido à varia- ω (rad/s) 100 200 300
ção de temperatura. Os dados experimentais são apresenta-
Torque (Nm) 35 47 55
dos na tabela. Use a interpolação de Newton para estimar
o comprimento da ponte em T = 40◦ C.
9. A deflexão de uma viga sob carga foi registrada para dife-
Temperatura (◦ C) 10 30 50 rentes posições, conforme a tabela. Estime a deflexão para
x = 5 m.
Comprimento (m) 100,00 100,12 100,26
Posição (m) 0 2 4 6
2. O consumo de energia de um motor foi registrado nas rota-
Deflexão (mm) 0 5 15 28
ções apresentadas na tabela. Estime, pela interpolação de
Newton, a potência para n = 1500 rpm.
10. Uma célula solar foi testada para diferentes intensidades
Rotação (rpm) 900 1200 1800 de luz. Use interpolação de Newton para estimar a tensão
gerada sob I = 600 W/m2 .
Potência (kW) 4,2 5,0 7,5
Intensidade (W/m2 ) 200 500 800
3. Em um ensaio de solos, foram obtidos os valores de resis-
tência ao cisalhamento para diferentes umidades conforme a Tensão (V) 0,45 0,50 0,53
tabela. Estime a resistência para uma umidade de w = 25%
usando interpolação de Newton. 11. O tempo de meia-vida de uma reação química foi regis-
trado em diferentes temperaturas. Estime, pelo método de
Umidade (%) 10 20 30 Newton, o tempo de meia-vida para T = 25◦ C.
Resistência (kPa) 22 18 13
Temperatura (◦ C) 10 20 40
4. O rendimento de um reator químico foi registrado para dife- t1/2 (min) 30 20 10
rentes temperaturas, conforme a tabela. Use interpolação
de Newton para estimar o rendimento em T = 175◦ C. 12. Em um processo de usinagem, a força de corte foi medida
◦ para diferentes avanços. Estime, via Newton, a força para
Temperatura ( C) 50 100 150 200
f = 0, 25 mm/volta.
Rendimento (%) 65 75 80 78
Avanço (mm/volta) 0,10 0,20 0,30
5. O coeficiente de arrasto CD de uma esfera em água foi tabe- Força (N) 200 250 320
lado para diferentes números de Reynolds. Use interpolação
de Newton para estimar CD em Re = 5 000. 13. A absorção de contaminantes por carvão ativado foi me-
Re 1,0 × 10 2
1,0 × 10 3
1,0 × 10 4 dida em diferentes concentrações. Estime a capacidade de
adsorção para C = 8 mg/L.
CD 1,20 0,47 0,25
Concentração (mg/L) 2 6 10
6. Para um material polimérico, as deformações observadas
Adsorção (mg/g) 1,1 2,0 2,6
para diferentes tensões estão na tabela. Calcule, por inter-
polação de Newton, a deformação para σ = 30 MPa.
14. A velocidade de sedimentação de partículas foi medida para
Tensão (MPa) 0 20 40 diferentes diâmetros. Calcule, por Newton, a velocidade
para d = 0, 05 mm.
Deformação 0,000 0,015 0,030
Diâmetro (mm) 0,01 0,03 0,07
7. O nível de poluentes em um rio foi monitorado nos instantes
abaixo. Estime, usando Newton, a concentração em t = 4 h. Velocidade (mm/s) 0,08 0,24 0,52

Tempo (h) 0 3 6 15. A eficiência de uma turbina eólica foi registrada para dife-
Concentração (mg/L) 1,5 1,1 0,9 rentes velocidades de vento. Estime, pela interpolação de
Newton, a eficiência para v = 10 m/s.
8. O torque transmitido por um eixo foi medido nas veloci-
Velocidade (m/s) 4 8 12
dades angulares apresentadas. Estime, via interpolação de
Newton, o torque para ω = 250 rad/s. Eficiência (%) 22 29 34
 14.9 Interpolação de Lagrange 189

Folha de Exercício 33: [Solução da Folha de Exercício 33]

1. O coeficiente de expansão térmica de um metal foi medido Temperatura (◦ C) 100 200 400 600
em várias temperaturas. Use o polinômio interpolador de
E (GPa) 200 192 180 150
Lagrange para estimar o coeficiente em T = 250◦ C e plote o
gráfico do polinômio junto aos pontos experimentais.
9. O teor de umidade de uma amostra de solo foi registrado em
Temperatura (◦ C) 100 200 300 400 várias profundidades. Use Lagrange para estimar a umidade
Expansão (10−6 /ºC) 12,1 13,0 14,2 15,9 em x = 0, 35 m e plote o gráfico.

Profundidade (m) 0,10 0,30 0,50

2. Em um teste de laboratório, a resistência elétrica de um
fio de cobre foi medida para diferentes comprimentos. Use Umidade (%) 18 23 25
Lagrange para estimar a resistência para L = 35 m e plote o
gráfico do polinômio e dos dados originais. 10. O pH de uma solução aquosa foi medido para diferentes
Comprimento (m) 10 20 40 50 temperaturas. Use o polinômio de Lagrange para estimar o
pH em T = 60◦ C e plote o gráfico do polinômio e dos dados.
Resistência (Ω) 2,1 4,3 8,7 10,7
Temperatura (◦ C) 20 40 80 100
3. O calor específico de um líquido foi tabelado para várias
temperaturas. Use o polinômio de Lagrange para estimar pH 7,2 7,0 6,7 6,6
cp em T = 55◦ C e plote o gráfico do polinômio e dos pontos.
11. A potência gerada por uma turbina hidráulica foi medida
Temperatura (◦ C) 20 40 80 para diferentes vazões. Use o polinômio de Lagrange para
cp (kJ/kg.K) 4,19 4,22 4,29 estimar a potência para Q = 700 L/s e plote o gráfico.

4. Uma viga de concreto foi submetida a diferentes cargas e Vazão (L/s) 400 600 800 1000
as flechas foram registradas. Use Lagrange para estimar a Potência (kW) 130 180 255 340
flecha para F = 60 kN e plote o gráfico do polinômio e dos
dados.
12. A altura de uma coluna de líquido foi registrada ao longo do
Carga (kN) 20 40 80 tempo. Use Lagrange para estimar a altura em t = 12 min e
plote o gráfico.
Flecha (mm) 0,9 2,7 6,5
Tempo (min) 0 10 20
5. A concentração de poluente em um lago foi monitorada
em diferentes horas do dia. Use Lagrange para estimar a Altura (cm) 100 65 42
concentração às 16 h e plote o gráfico do polinômio e dos
dados. 13. O consumo de energia de um equipamento foi monitorado ao
Hora (h) 8 12 18 22 longo de três meses. Use Lagrange para estimar o consumo
no 2º mês e plote o gráfico.
Concentração (mg/L) 0,20 0,27 0,18 0,14
Mês 1 3 4
6. O rendimento de uma reação química foi registrado para
diferentes concentrações de reagente. Use Lagrange para Consumo (kWh) 430 512 610
estimar o rendimento para C = 0, 45 mol/L e plote o gráfico
do polinômio e dos dados. 14. O teor de oxigênio dissolvido em um tanque de aeração
foi medido em diferentes velocidades de agitação. Use o
Concentração (mol/L) 0,2 0,4 0,6
polinômio de Lagrange para estimar o teor em v = 45 rpm e
Rendimento (%) 68 74 79 plote o gráfico.

7. Em um teste hidráulico, a vazão de uma bomba foi regis- Velocidade (rpm) 30 60 90

trada para diferentes rotações. Use Lagrange para estimar
Oxigênio (mg/L) 6,8 7,3 8,1
a vazão em N = 2000 rpm e plote o gráfico.

Rotação (rpm) 1200 1800 2400 15. A pressão em um tubo foi medida em diferentes distâncias
3 da bomba. Use Lagrange para estimar a pressão em d = 17 m
Vazão (m /h) 20 31 52
e plote o gráfico do polinômio e dos pontos experimentais.
8. O módulo de elasticidade de um material foi tabelado para
Distância (m) 0 10 20
diferentes temperaturas. Use Lagrange para estimar E em
T = 350◦ C e plote o gráfico. Pressão (kPa) 90 82 74
 15. Sistemas de Equações Lineares e Matrizes

15.1 Resolução de Sistemas Lineares

Sistemas de equações lineares podem ser resolvidos por meio de métodos iterativos. Nessa
abordagem, o sistema é reescrito em uma forma explícita, na qual cada incógnita é isolada
em função das demais. Esse rearranjo permite obter aproximações sucessivas para as
variáveis até que a solução atenda a um critério de convergência previamente estabelecido.
A Equação (15.1) apresenta um sistema linear genérico com quatro equações e quatro
incógnitas. A forma explícita correspondente, usada nos métodos iterativos, é mostrada na
Equação (15.2).

Sistema original ((15.1)) Forma explícita ((15.2))

1
a11 x1 + a12 x2 + a13 x3 + a14 x4 = b1 x1 = (b1 − a12 x2 − a13 x3 − a14 x4 )
a11
1
a21 x1 + a22 x2 + a23 x3 + a24 x4 = b2 x2 = (b2 − a21 x1 − a23 x3 − a24 x4 )
a22
1
a31 x1 + a32 x2 + a33 x3 + a34 x4 = b3 x3 = (b3 − a31 x1 − a32 x2 − a34 x4 )
a33
1
a41 x1 + a42 x2 + a43 x3 + a44 x4 = b4 x4 = (b4 − a41 x1 − a42 x2 − a43 x3 )
a44

O método iterativo para resolução de sistemas lineares começa com a escolha de valores
iniciais para todas as incógnitas. Esses valores formam a primeira estimativa da solução.
Na primeira iteração, essa estimativa inicial é substituída no lado direito das equações,
permitindo o cálculo de uma nova estimativa, chamada segunda solução estimada.
Na segunda iteração, os novos valores obtidos são novamente substituídos no sistema,
resultando na terceira estimativa, e assim por diante. Esse processo é repetido até que
as estimativas sucessivas se tornem suficientemente próximas umas das outras. Quando
isso ocorre, dizemos que o método convergiu, e a estimativa obtida é considerada uma
aproximação da solução real do sistema.
 192 Capítulo 15. Sistemas de Equações Lineares

15.2 Método de Jacobi

No método de Jacobi, o processo começa com a escolha de um valor inicial para cada uma
das incógnitas do sistema. Esses valores constituem a estimativa inicial da solução, e
(0) (0) (0) (0)
são representados por x1 , x2 , . . . , xj , . . . , xn . O número entre parênteses no expoente,
chamado de índice de iteração, indica a etapa do processo iterativo em que o valor foi
calculado.
(0)
No caso de xj , o expoente (0) indica que se trata da estimativa na iteração zero,
ou seja, o valor inicial atribuído à variável xj antes de qualquer atualização. Esses valores
iniciais podem ser escolhidos com base em alguma estimativa conhecida, mas, na ausência
de informação adicional, é comum assumir simplesmente que:
(0) (0) (0)
x1 = x2 · · · = xj = · · · = x(0)
n =0 j = 1, 2, . . . , n (15.3)

(0)
Com essas estimativas iniciais xj , calculamos a primeira estimativa da solução,
(1) (1) (1) (1)
x1 , x2 , x3 , . . . , xn , substituindo os valores da estimativa inicial no lado direito da
Equação (15.4). Assim, temos:
  
n
(1) 1  X
bi −  (0) 
xi = aij · xj   i = 1, 2, . . . , n (15.4)
aii  
j=1

j̸=i

A forma expandida da Equação (15.4) para n = 4, onde cada equação corresponde ao

(1) (0)
cálculo da primeira iteração xi , a partir das estimativas iniciais xj com j ̸= i:

(1) 1 h (0) (0) (0)

i
x1 = b1 − (a12 · x2 + a13 · x3 + a14 · x4 )
a11
(1) 1 h (0) (0) (0)
i
x2 = b2 − (a21 · x1 + a23 · x3 + a24 · x4 )
a22
(1) 1 h (0) (0) (0)
i
x3 = b3 − (a31 · x1 + a32 · x2 + a34 · x4 )
a33
(1) 1 h (0) (0) (0)
i
x4 = b4 − (a41 · x1 + a42 · x2 + a43 · x3 ) (15.5)
a44

Esse processo é repetido a cada nova iteração. De forma geral, a estimativa da (k + 1)-
ésima iteração para cada incógnita é calculada com base nos valores obtidos na k-ésima
iteração. O critério de parada do método pode ser definido de modo que as iterações
sejam interrompidas quando as estimativas deixarem de apresentar variações significativas.
Assim, podemos definir o critério de parada de acordo com a Equação(15.6)
(k+1) (k)
xi − xi <ε para i = 1, 2, . . . , n (15.6)

Para que o método de Jacobi seja aplicável, é necessário que o sistema linear
seja quadrado, ou seja, que o número de equações seja igual ao número de
incógnitas. Sistemas não quadrados, com mais equações do que incógnitas ou vice-versa,
não são compatíveis com a formulação clássica do método, pois não permitem a atualização
simultânea de todas as variáveis a partir de equações independentes.
15.2 Método de Jacobi 193

Exemplo: 7
Exercício: Resolva o seguinte sistema linear usando o método de Jacobi.

 10x1 + 2x2 + x3 = 9


2x1 + 20x2 − 2x3 = −44

−2x1 + 3x2 + 10x3 = 22


Solução: Usando a Equação:

  
n
(k+1) 1   X (0) 

xi = bi −  aij · xj  i = 1, 2, . . . , n
aii   
j=1
j̸=i

Iteração: k = 0
(0)
Definimos a aproximação inicial xi = 0 para i = 1, 2, . . . , n.
(0) (0) (0)
x1 = 0, x2 = 0, x3 = 0
(k+1)
Atualizamos os valores de xi para i = 1, 2, . . . , n.
(1) 1
x1 = 9 − (2 · 0) + (1 · 0)
= 0.9000


10
(1) 1
x2 = − 44 − (2 · 0) + (−2 · 0) = −2.2000


20
(1) 1
x3 = 22 − (−2 · 0) + (3 · 0) = 2.2000


10
Iteração: k = 1
(k+1)
Atualizamos os valores de xi para i = 1, 2, . . . , n.
1
(2)
x1 = 9 − (2 · −2.2) + (1 · 2.2) = 1.1200


10
(2) 1
x2 = − 44 − (2 · 0.9) + (−2 · 2.2) = −2.0700


20
(2) 1
x3 = 22 − (−2 · 0.9) + (3 · −2.2) = 3.0400


10
Iteração: k = 2
(k+1)
Atualizamos os valores de xi para i = 1, 2, . . . , n.
1
(3)
x1 = 9 − (2 · −2.07) + (1 · 3.04) = 1.0100


10
(3) 1
x2 = − 44 − (2 · 1.12) + (−2 · 3.04) = −2.0080


20
(3) 1
x3 = 22 − (−2 · 1.12) + (3 · −2.07) = 3.0450


10
O processo continua até que o erro relativo seja inferior ε = 10−4 .

Iteração x1 x2 x3
k = 0 0.00000 0.00000 0.00000
k = 1 0.90000 -2.20000 2.20000
k = 2 1.12000 -2.07000 3.04000
k = 3 1.01000 -2.00800 3.04500
k = 4 0.99710 -1.99650 3.00440
k = 5 0.99886 -1.99927 2.99837
k = 6 1.00002 -2.00005 2.99955
k = 7 1.00005 -2.00005 3.00002
k = 8 1.00001 -2.00000 3.00002
k = 9 1.00000 -2.00000 3.00000
 194 Capítulo 15. Sistemas de Equações Lineares

15.3 Método de Gauss-Seidel

O método de Gauss-Seidel é uma variação do método de Jacobi e também é utilizado
para encontrar soluções aproximadas de sistemas lineares da forma Ax = b, onde A é
uma matriz quadrada de ordem n, x é o vetor das incógnitas e b é o vetor dos termos
independentes.
A principal diferença em relação ao método de Jacobi está na forma como os valores
das incógnitas são atualizados. Enquanto no método de Jacobi todas as variáveis de uma
iteração dependem apenas dos valores da iteração anterior, no Gauss-Seidel cada variável é
atualizada assim que seu novo valor é calculado, e esse valor mais recente já é utilizado
imediatamente no cálculo das próximas variáveis.
(0)
A estimativa inicial xj é fornecida de forma semelhante ao método de Jacobi, sendo
comum assumir:

(0) (0)
x1 = x2 = · · · = x(0)
n =0 (15.7)

Com essa estimativa inicial, o cálculo da primeira iteração no Gauss-Seidel é feito

sequencialmente. A equação geral de atualização é dada por:
 
i−1 n
(k+1) 1  X (k+1) X (k)
xi = bi − aij xj − aij xj  i = 1, 2, . . . , n (15.8)
aii j=1 j=i+1

(k+1)
Note que os valores xj com j < i já foram atualizados dentro da mesma iteração,
(k)
enquanto os valores xj
com j > i ainda pertencem à iteração anterior. Essa utilização
imediata dos valores mais recentes é o que torna o Gauss-Seidel, em geral, mais eficiente
que o Jacobi.
Para o caso de quatro variáveis, a forma expandida da Equação (15.8) é:

(k+1) 1 h (k) (k) (k)

i
x1 =b1 − (a12 x2 + a13 x3 + a14 x4 )
a11
(k+1) 1 h (k+1) (k) (k)
i
x2 = b2 − (a21 x1 + a23 x3 + a24 x4 )
a22
(k+1) 1 h (k+1) (k+1) (k)
i
x3 = b3 − (a31 x1 + a32 x2 + a34 x4 )
a33
(k+1) 1 h (k+1) (k+1) (k+1)
i
x4 = b4 − (a41 x1 + a42 x2 + a43 x3 ) (15.9)
a44

Assim como no método de Jacobi, o processo iterativo continua até que a diferença
entre as estimativas obtidas em duas iterações consecutivas seja suficientemente pequena.
O critério de parada pode ser estabelecido pelo erro relativo, conforme a Equação (15.6),
previamente apresentada.
O método de Gauss-Seidel tende a convergir mais rapidamente do que o método de
Jacobi, especialmente quando a matriz A é diagonal dominante ou simétrica definida
positiva. No entanto, assim como outros métodos iterativos, sua convergência não é
garantida em todos os casos. Por isso, é importante verificar as condições do sistema antes
de aplicar o método.
15.3 Método de Gauss-Seidel 195

Exemplo: 8
Exercício: Resolva o seguinte sistema linear usando o método de Gauss-Seidel.

 10x1 + 2x2 + x3 = 9


2x1 + 20x2 − 2x3 = −44

−2x1 + 3x2 + 10x3 = 22


Solução: Usando a Equação:

 
i−1 n
(k+1) 1  X (k+1)
X (k)
xi = bi − aij xj − aij xj  i = 1, 2, . . . , n
aii
j=1 j=i+1

Iteração: k = 0
(0)
Definimos a aproximação inicial xi = 0 para i = 1, 2, . . . , n.
(0) (0) (0)
x1 = 0, x2 = 0, x3 = 0
(k+1)
Atualizamos os valores de xi para i = 1, 2, . . . , n.
(1) 1
x1 = 9 − (2 · 0) + (1 · 0)
= 0.9000


10
(1) 1
x2 = − 44 − (2 · 0.9) + (−2 · 0) = −2.2900


20
(1) 1
x3 = 22 − (−2 · 0.9) + (3 · −2.29) = 3.0670


10
Iteração: k = 1
(k+1)
Atualizamos os valores de xi para i = 1, 2, . . . , n.
(2) 1
x1 = 9 − (2 · −2.29) + (1 · 3.067) = 1.0513


10
(2) 1
x2 = − 44 − (2 · 1.0513) + (−2 · 3.067) = −1.99843


20
(2) 1
x3 = 22 − (−2 · 1.0513) + (3 · −1.99843) = 3.00979


10
Iteração: k = 2
(k+1)
Atualizamos os valores de xi para i = 1, 2, . . . , n.
(3)1
x1 = 9 − (2 · −1.99843) + (1 · 3.00979) = 0.99871


10
(3) 1
x2 = − 44 − (2 · 0.99871) + (−2 · 3.00979) = −1.99889


20
(3) 1
x3 = 22 − (−2 · 0.99871) + (3 · −1.99889) = 2.99941


10
O processo continua até que o erro relativo seja inferior ε = 10−4 .

Iteração xk1 xk2 xk3

k = 0 0.00000 0.00000 0.00000
k = 1 0.90000 -2.29000 3.06700
k = 2 1.05130 -1.99843 3.00979
k = 3 0.99871 -1.99889 2.99941
k = 4 0.99984 -2.00004 2.99998
k = 5 1.00001 -2.00000 3.00000
k = 6 1.00000 -2.00000 3.00000
k = 7 1.00000 -2.00000 3.00000
k = 8 1.00000 -2.00000 3.00000
k = 9 1.00000 -2.00000 3.00000
 196 Capítulo 15. Sistemas de Equações Lineares

Folha de Exercício 34: [Solução da Folha de Exercício 34]

1. Resolva o seguinte sistema linear utilizando o método de 6. O cálculo de correntes em um circuito elétrico resulta no
Jacobi até a terceira iteração. sistema:

10x1 + 2x2 + x3 = 9 7i1 − 2i2 + i3 = 5

2x1 + 20x2 − 2x3 = −44 −2i1 + 8i2 − i3 = −3

−2x1 + 3x2 + 10x3 = 22 i1 − i2 + 6i3 = 4

Resolva pelo método de Jacobi até convergir em quatro casas

2. Um circuito elétrico possui o seguinte sistema de equações
decimais.
(Lei de Kirchhoff). Resolva numericamente pelo método de
Jacobi até a quarta iteração. 7. Considere o sistema de equações do modelo de malhas em
uma rede elétrica:
5i1 − i2 − i3 = 10
10v1 − 2v2 − v3 = 7
−i1 + 4i2 − i3 = 12
−2v1 + 9v2 − 3v3 = −8
−i1 − i2 + 3i3 = 0
−v1 − 3v2 + 12v3 = 15
3. Considere o problema de equilíbrio de forças em uma
(15.10)
treliça plana. As equações lineares resultantes são:

12x1 − 3x2 + 2x3 = 15 Resolva pelo método de Jacobi até k = 5.

8. Em um problema de transferência de calor 2D simplificado,
−3x1 + 10x2 − x3 = 27 o sistema linear obtido foi:
2x1 − x2 + 8x3 = −9 4T1 − T2 − T3 = 100
Resolva pelo método de Jacobi até obter aproximação com
−T1 + 4T2 − T4 = 0
três casas decimais até a quarta iteração.
4. Implemente em Python um código que calcule e plote o −T1 + 4T3 − T4 = 50
erro por iteração no método de Jacobi, para o sistema das
−T2 − T3 + 4T4 = 200
Questões 1, 2, 3 e 4.
5. Escreva um programa em Python que resolva o sistema Resolva pelo método de Jacobi até convergência.
linear utilizando o Método de Jacobi. O sistema descreve 9. Resolva pelo método de Jacobi o seguinte sistema de equa-
um problema de equilíbrio estrutural onde x1 , x2 , x3 são os ções derivado da discretização de uma viga engastada:
deslocamentos nos nós de uma estrutura:
20x1 − 4x2 = 10
15x1 + x2 − x3 = 20
−4x1 + 20x2 − 4x3 = 0
x1 + 12x2 + 2x3 = 33
−4x2 + 20x3 = 5
−2x1 + x2 + 10x3 = −7

Realize as iterações até que o erro médio entre duas iterações 10. Resolva o sistema linear abaixo pelo método de Jacobi:
consecutivas seja inferior a ε = 10−3 , utilizando Equação:
9x1 + x2 + x3 = 10
Pn (k+1) (k)
i=1 |xi − xi |
2x1 + 12x2 − x3 = 20
<ε
n
x1 − 2x2 + 15x3 = 30
 15.3 Método de Gauss-Seidel 197

Folha de Exercício 35: [Solução da Folha de Exercício 35]

1. Em um modelo de distribuição de temperatura, as variá- 6. Resolva pelo método de Gauss-Seidel o seguinte sistema de
veis T1 , T2 e T3 obedecem ao sistema: correntes elétricas:

8T1 + T2 − T3 = 15 7i1 − 2i2 + i3 = 5 (15.23)

2T1 + 10T2 + T3 = 25 −2i1 + 8i2 − i3 = −3 (15.24)

T1 − T2 + 5T3 = 10 i1 − i2 + 6i3 = 4 (15.25)

Utilize o método iterativo de Gauss-Seidel para encontrar

7. Resolva o sistema linear de uma rede elétrica pelo método
a aproximação depois de 5 iterações.
de Gauss-Seidel:
2. Resolva o sistema proveniente da análise de malhas em um
circuito elétrico, aplicando o método de Gauss-Seidel. 10v1 − 2v2 − v3 = 7 (15.26)

5i1 − i2 − i3 = 10 (15.11) −2v1 + 9v2 − 3v3 = −8 (15.27)

−i1 + 4i2 − i3 = 12 (15.12) −v1 − 3v2 + 12v3 = 15 (15.28)

−i1 − i2 + 3i3 = 0 (15.13) 8. Resolva o problema de transferência de calor 2D simplificado

com Gauss-Seidel:
3. Resolva o sistema de forças em equilíbrio de uma treliça
plana pelo método de Gauss-Seidel: 4T1 − T2 − T3 = 100 (15.29)

12x1 − 3x2 + 2x3 = 15 (15.14) −T1 + 4T2 − T4 = 0 (15.30)

−3x1 + 10x2 − x3 = 27 (15.15) −T1 + 4T3 − T4 = 50 (15.31)

2x1 − x2 + 8x3 = −9 (15.16) −T2 − T3 + 4T4 = 200 (15.32)

4. Resolva numericamente o sistema associado à transferência 9. Resolva numericamente o sistema derivado da discretização
de calor em uma barra metálica: de uma viga engastada:
4T1 − T2 = 100 (15.17) 20x1 − 4x2 = 10 (15.33)
−T1 + 4T2 − T3 = 200 (15.18) −4x1 + 20x2 − 4x3 = 0 (15.34)
−T2 + 4T3 = 300 (15.19) −4x2 + 20x3 = 5 (15.35)

5. Resolva manualmente até k = 4 o sistema: 10. Resolva o sistema abaixo pelo método de Gauss-Seidel até
15x1 + x2 − x3 = 20 (15.20) convergência com 4 casas decimais:

9x1 + x2 + x3 = 10 (15.36)
x1 + 12x2 + 2x3 = 33 (15.21)
2x1 + 12x2 − x3 = 20 (15.37)
−2x1 + x2 + 10x3 = −7 (15.22)
x1 − 2x2 + 15x3 = 30 (15.38)
 198 Capítulo 15. Sistemas de Equações Lineares

Folha de Exercício 36: [Solução da Folha de Exercício 36]

36.
 16. Integração Numérica

16.1 Introdução
A operação de integração desempenha um papel fundamental na formulação e solução de
problemas em diversas áreas da engenharia, física, estatística e outras ciências aplicadas.
Ela está presente no cálculo de áreas, volumes, centros de massa, trabalho, energia, e
também na resolução de equações diferenciais.
Em muitos casos, a integração analítica, ou seja, a obtenção de uma solução exata por
meio de técnicas de cálculo simbólico, pode ser muito difícil ou até mesmo impossível. Nessas
situações, recorre-se aos métodos numéricos de integração para obter aproximações
da integral definida com a precisão desejada. Diversas circunstâncias justificam a adoção
de métodos numéricos:
2
• Funções sem antiderivada elementar: Algumas funções, como f (x) = e−x ,
não possuem uma antiderivada expressável em termos de funções elementares. Isso
impede a obtenção de uma solução exata via cálculo simbólico, tornando necessário
o uso de técnicas numéricas.
• Funções definidas por dados experimentais: Em muitas aplicações práticas,
especialmente na engenharia e na física experimental, a função que se deseja integrar
é conhecida apenas por um conjunto de dados tabulados, provenientes de medições
ou simulações computacionais. Nesses casos, a função subjacente não possui uma
expressão analítica, e a integração precisa ser feita numericamente.
• Modelagem computacional e grandes volumes de dados: Em contextos como
aprendizado de máquina, otimização e análise estatística de grandes bases de dados,
integrais definidas frequentemente aparecem em expressões envolvendo funções de
custo, estimativas de probabilidade e distribuições estatísticas. A complexidade ou o
tamanho dessas funções torna o uso de integração numérica indispensável.
• Integrais multidimensionais: Quando a integral envolve múltiplas variáveis (como
integrais duplas, triplas ou integrais de volume), a dificuldade do processo analítico
cresce significativamente, e métodos numéricos, como quadratura múltipla ou Monte
Carlo, tornam-se ferramentas fundamentais.
 200 Capítulo 16. Integração Numérica

16.2 Fundamentos
A integração numérica tem como objetivo estimar o valor de uma integral definida, ou
seja, calcular numericamente a área sob a curva de uma função f (x) no intervalo [a, b].
Esse valor é representado por:
Z b
I(f ) = f (x) dx (16.1)
a

A interpretação geométrica da integral definida é a área delimitada entre a curva da

função f (x), o eixo x e as retas verticais x = a e x = b:

3
f (x)

2
b f (x)

1 A

x
1 2 3 4 5 6 7 8 9

Figura 16.1: Interpretação Geométrica da Integral Definida para Integração Numérica

Quando a função f (x) possui uma expressão analítica conhecida, podemos aplicar
métodos numéricos que avaliam a função em um número finito de pontos para obter uma
aproximação da integral. Uma abordagem simples seria considerar apenas os valores da
função nas extremidades do intervalo, ou seja, os pares (a, f (a)) e (b, f (b)). No entanto,
essa estratégia pode levar a erros significativos quando: (i) o intervalo [a, b] é relativamente
grande ou (ii) a função f (x) apresenta variações acentuadas ao longo do intervalo.
Para melhorar a precisão, uma estratégia comum é dividir o intervalo [a, b] em subinter-
valos menores e aplicar a regra de integração em cada um deles. Os resultados parciais são
então somados para fornecer uma estimativa mais precisa da integral. Esse procedimento é
conhecido como método composto.
Em algumas aplicações práticas, a função f (x) não é conhecida por uma equação, mas
por um conjunto de valores obtidos experimentalmente (dados tabulados). Nesses casos, a
integração numérica deve ser feita diretamente sobre os pontos disponíveis. Assim:
• Se f (x) for conhecida analiticamente, os pontos de amostragem podem ser escolhidos
pelo usuário ou definidos pelo próprio método numérico;
• Se f (x) for conhecida apenas por dados tabelados, os pontos são fixos e não podem
ser alterados.
Em todos os casos, a ideia central consiste em deduzir uma fórmula que permita
calcular uma boa aproximação da integral com base em valores discretos da função. Entre
os métodos mais conhecidos e aplicados estão o método dos retângulos, o método dos
trapézios e a regra de Simpson.
 16.3 Fórmulas de Integração de Newton-Cotes 201

16.3 Fórmulas de Integração de Newton-Cotes

As fórmulas de integração de Newton-Cotes são uma família de métodos numéricos usados
para aproximar o valor de integrais definidas. Esses métodos são baseados na ideia de
interpolar a função a ser integrada por um polinômio de grau n que passa por um conjunto
de pontos igualmente espaçados e, em seguida, integrar esse polinômio de forma exata.
Assim:
Z b Z b
A= f (x)dx ≈ fn (x)dx (16.2)
a a

onde fn (x) é um polinômio interpolador construido com base em n + 1 pontos no intervalo

[a, b] da forma:

fn (x) = a0 + a1 x + · · · + an−1 xn−1 + an xn (16.3)

em que n é o grau do polinômio. Por exemplo, a Figura 16.2, um polinômio de primeiro

grau (uma reta) é usado como uma aproximação. A Figura 16.2 três segmentos de reta são
usados para aproximar a integral.

f (x)
a

2
b f (x)

1 A

x
1 2 3 4 5 6 7 8 9

f (x) x0 = a x1

2 x2 x3 = b
f (x)

1 A2 A1 A3

x
1 2 3 4 5 6 7 8 9

Figura 16.2: Interpretação Gráfica da Regra do Trapézio (Newton-Cotes de Grau 1).

 202 Capítulo 16. Integração Numérica

16.4 Método dos Trapézios

O método dos Trapézios é uma técnica de integração numérica que visa aproximar a área
sob uma curva no intervalo [a, b] por uma figura geométrica simples: o trapézio. No caso
mais básico, também chamado de fórmula do trapézio simples, utiliza-se apenas dois pontos
da função, os extremos do intervalo a e b, com suas respectivas imagens f (a) e f (b). Como
dois pontos determinam uma única reta, traça-se uma linha reta ligando os pontos (a, f (a))
e (b, f (b)), que funciona como uma aproximação linear da função original nesse intervalo.
Neste contexto, h = b − a representa a largura da base do trapézio.
A área sob essa reta, limitada pelo eixo x, forma um trapézio que pode ser calculado
pela fórmula clássica da área de um trapézio:
hh i
A(f ) = f (xa ) + f (xb ) (16.4)
2

f (x)
h
3

2
b f (x)

1 A

x
1 2 3 4 5 6 7 8 9

Exemplo: 9
Calcule a Integral pelo método dos trapézios usando uma única reta.
3.6
1
Z
I= dx (16.5)
3 x
Pelo método dos trapézios:

0.6 1 1
   
h
A = f (xa ) + f (xb ) = + = 0.18333
2 2 3 3.6
Pelo cálculo integral:
3.6
1
Z
dx = ln(3.6) − ln(3) = 0.18232
3 x

Assim, podemos calcular o erro relativo (ER):

|0.18333 − 0.18232|
ER = = 0.0055397104
0.18232
 16.5 Método dos Trapezios Composto 203

16.5 Método dos Trapezios Composto

A integral definida no intervalo [a, b] pode ser avaliada de forma mais precisa quando o
intervalo é subdividido em partes menores, chamadas de subintervalos. Essa estratégia
consiste em aproximar a área sob a curva da função f (x) em [a, b] por meio da soma das
áreas aproximadas em cada subintervalo. A ideia central é que, ao considerar segmentos
menores, a função tende a se comportar de forma mais regular dentro de cada trecho, o
que permite uma aproximação mais fiel do valor da integral total.
No caso do método dos trapézios composto, o intervalo [a, b] é dividido em n subintervalos
consecutivos, o que implica a definição de n + 1 pontos igualmente ou desigualmente
espaçados, denotados por x0 , x1 , x2 , . . . , xn , onde x0 = a e xn = b. Cada subintervalo é,
portanto, da forma [xi , xi+1 ], com i variando de 0 até n − 1. A escolha adequada do número
de subintervalos n afeta diretamente a precisão do método, uma vez que quanto menor for
a largura dos subintervalos, menor será o erro associado à aproximação trapezoidal em
cada trecho.
Essa construção é ilustrada na Figura 16.3, que mostra a função f (x) sendo aproximada
por segmentos de reta entre os pontos sucessivos (xi , f (xi )). O somatório das áreas dos
trapézios formados por essas retas fornece uma aproximação eficiente para o valor da
integral definida original.

f (x) x2
h
6 x1 x3

4 x0 = a x4

x5
2
x6 = b

A1 A2 A3 A4 A5 A6
x
0
0 1 2 3 4 5 6 7 8

Figura 16.3: Método dos Trapezios Composto.

A integral ao longo do intervalo completo pode ser escrita como a soma das integrais
dos subintervalos:

Z b
A(f ) = f (x)dx
a
Z x1 Z x2 Z xi +1 Z xn
= f (x)dx + f (x)dx + · · · + f (x)dx + · · · + f (x)dx
x0 =a x1 xi xn−1

n−1
X Z xi+1
= f (x) (16.6)
i=0 xi
204 Capítulo 16. Integração Numérica

Aplicando o método do trapézio (Equação 16.4) a cada subintervalo [xi , xi+1 ] da partição
do intervalo [a, b], obtemos uma aproximação local da integral da função f (x) nesse trecho.
A fórmula trapezoidal aproxima a área sob a curva como a área de um trapézio, cuja base
é dada por (xi+1 − xi ) e as alturas são os valores da função nos extremos do subintervalo,
isto é, f (xi ) e f (xi+1 ):
hh i
≈ f (xa ) + f (xb )
2
Z xi+1
(xi+1 − xi ) h i
f (x) dx ≈ f (xi ) + f (xi+1 ) (16.7)
xi 2

Substituindo essa expressão aproximada para cada subintervalo na soma das integrais
parciais (conforme Equação 16.6), obtemos a fórmula geral do método dos trapézios
composto:

n−1
X (xi+1 − xi )
A(f ) ≈ [f (xi ) + f (xi+1 )] (16.8)
i=0
2

A Equação 16.8 representa a fórmula geral do método dos trapézios composto. Note
que os subintervalos [xi , xi+1 ] não precisam ter a mesma largura; ou seja, o método é
aplicável mesmo com subintervalos desiguais. No entanto, se todos os subintervalos forem
de mesmo comprimento, temos:

(x1 − x0 ) = (x2 − x1 ) = · · · = (xi+1 − xi ) = · · · = (xn − xn−1 ) = h (16.9)

Nesse caso, a Equação 16.8 pode ser simplificada para:

h n−1
Xh i
I(f ) ≈ f (xi ) + f (xi+1 ) (16.10)
2 i=0

Expandindo a soma da Equação 16.10, percebemos que os termos intermediários da

função f (xi ) aparecem duas vezes, uma vez para cada subintervalo adjacente, enquanto
os extremos aparecem apenas uma vez. Isso nos leva a uma forma mais conveniente para
implementação computacional:
hh i
I(f ) ≈ f (xa ) + 2f (x1 ) + 2f (x2 ) + · · · + 2f (xn−1 ) + f (xb ) (16.11)
2
ou, de maneira equivalente, usando a notação de somatório com o fator 2 dentro da soma:

n−1
" ! #
h X
I(f ) ≈ f (xa ) + 2f (xi ) + f (xb ) (16.12)
2 i=1

A Equação 16.12 constitui a forma final e otimizada do método dos trapézios composto
para o caso de subintervalos igualmente espaçados.
16.5 Método dos Trapezios Composto 205

Exemplo: 10
Calcule a aproximação da seguinte integral 16.13 usando a regra dos trapezios com 3 e 11 pontos.
Z 1
x3 dx (16.13)
0

Solução: Considerando n = 3 o número de pontos, o total de intervalos será n − 1. Então:

b−a 1−0 1
h= = = = 0.5
n−1 3−1 2
Logo meus pontos serão: x0 = 0, x1 = 0.5 e x2 = 1. Agora calculanos os valores de f (x), temos:
f (x0 ) = 0, f (x1 ) = 0.53 = 0.125, f (x2 ) = 1. Agora vamos aplicar a equacao 14.10:
h
h i
I(f ) ≈ f (x0 ) + 2f (x1 ) + f (x2 )
2
0.5
h i
≈ 0 + 2(0.125) + 1
2

≈ 0.3125 (16.14)

Considerando n = 11 o número de pontos, o total de intervalos será n − 1. Então:

b−a 1−0 1
h= = = = 0.1
n−1 11 − 1 10
Logo podemos montar uma tabela com os seguintes pontos:

x 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

f (x) 0 0.001 0.008 0.027 0.064 0.125 0.216 0.343 0.512 0.729 1

Agora vamos aplicar a equacao 14.10:

h
h i
I(f ) ≈ f (x0 ) + 2f (x1 ) + 2f (x2 ) + · · · + 2f (x9 ) + f (x10 )
2
0.1
h i
≈ 0 + 2(0.001) + 2(0.008) + · · · + 2(0.729) + 1
2

≈ 0.2525 (16.15)
R1
Considerando que a integral de 0
x3 dx = 0.25, os erros absoluto e relativo, respectivamente, são:
0.0025 e 0.0100.
 206 Capítulo 16. Integração Numérica

16.6 Método de Simpson

O método do trapézio, descrito na seção anterior, aproxima o integrando por um segmento
de reta (Figura 16.4). Em princípio, é possível obter aproximações mais precisas ao
representar o integrando por funções não lineares de fácil integração (Figura 16.5). Uma
classe de métodos que segue essa ideia, denominada regras de Simpson, utiliza (i)
polinômios quadráticos (regra de Simpson 1/3) e (ii) cúbicos (regra de Simpson 3/8)
para aproximar a função integranda.
Outra maneira de melhorar a precisão na estimativa de integrais, além da aplicação da
regra do trapézio com subdivisões menores, é empregar polinômios de grau mais elevado
para conectar os pontos. Por exemplo, se for incluído um ponto adicional no ponto médio
entre f (a) e f (b), os três pontos podem ser ajustados por uma parábola. As fórmulas
obtidas pela integração desses polinômios são conhecidas como regras de Simpson.

2.5

1.5

0.5

0.15 0.2 0.25 0.3 0.35 0.4 0.45 0.5

Figura 16.4: Aproximação do integrando pela regra do trapézio.

2.5

1.5

0.5

0.15 0.2 0.25 0.3 0.35 0.4 0.45 0.5

Figura 16.5: Aproximação do integrando pela regra de Simpson (ajuste parabólico).

 16.6 Método de Simpson 207

16.6.1 Método de Simpson 1/3

Além de aplicar a regra do trapézio com subdivisões menores, outra forma de obter uma
estimativa mais precisa de uma integral definida é utilizar polinômios de grau mais elevado
para conectar os pontos. Neste método, emprega-se um polinômio quadrático (de
segunda ordem) para aproximar o integrando.
Os coeficientes do polinômio quadrático podem ser determinados a partir de três pontos
distintos. Para calcular a integral no intervalo [a, b], consideram-se os dois pontos extremos
x0 = a e x2 = b, além do ponto médio x1 = (a + b)/2.
Para construir esse polinômio, utiliza-se o interpolador de Lagrange, pois ele fornece
uma forma direta e sistemática de obter um polinômio de grau n que passa exatamente
por n + 1 pontos conhecidos da função. Assim, com apenas os valores da função f (x)
nos pontos escolhidos, é possível escrever explicitamente o polinômio aproximador sem
a necessidade de resolver sistemas lineares de coeficientes. O polinômio interpolador de
Lagrange para três pontos (x0 , x1 , x2 ) é dado pela Equação:

p(x) = f (x0 )L0 (x) + f (x1 )L1 (x) + f (x2 )L2 (x) (16.16)

onde:
(x − x1 )(x − x2 ) (x − x0 )(x − x2 ) (x − x0 )(x − x1 )
L0 (x) = L1 (x) = L2 (x) =
(x0 − x1 )(x0 − x2 ) (x1 − x0 )(x1 − x2 ) (x2 − x0 )(x2 − x1 )
Assim, a integral aproximada da regra de Simpson é:
Z x2 Z x2
f (x)dx ≈ p(x)dx
x0 x0

Substituindo o p(x) pela Equação 16.16, temos:

Z x2 Z x2 " #
p(x)dx = f (x0 ) · L0 (x)dx + f (x1 ) · L1 (x)dx + f (x2 ) · L2 (x)dx (16.17)
x0 x0

Substituindo os valores de L0 , L1 e L2 , temos:

Z x2 " #
(x − x1 )(x − x2 ) (x − x0 )(x − x2 ) (x − x0 )(x − x1 )
f (x0 ) + f (x1 ) + f (x2 ) dx
x0 (x0 − x1 )(x0 − x2 ) (x1 − x0 )(x1 − x2 ) (x2 − x0 )(x2 − x1 )

Considerando que os pontos são pontos igualmente espaçados entre f (a) e f (b):

x1 = x0 + h
x2 = x0 + 2h = x1 + h (16.18)

Aplicando um pouco de algebra, podemos obter a Equação final:

Z x2
hh i
p(x)dx ≈ f (x0 ) + 4 · f (x1 ) + f (x2 ) (16.19)
x0 3

para esse caso, h = (b − a)/2. Essa equação é conhecida como a regra 1/3 de Simpson. A
designação 1/3 vem do fato que h está dividido por 3 na Equação 16.19.
 208 Capítulo 16. Integração Numérica

16.7 Método de Simpson 1/3 Composta

O Método de Simpson 1/3 composta é uma extensão da fórmula simples, aplicada
quando o intervalo [a, b] é subdividido em n − 1 subintervalos iguais, sendo n o número
total de pontos igualmente espaçados. Para que a fórmula seja válida, n − 1 deve ser par,
ou seja, o número total de pontos n deve ser ímpar. Cada par de subintervalos consecutivos
é aproximado por um polinômio quadrático, e o resultado final é a soma das aproximações
locais.
b−a
h= , xi = a + ih, i = 0, 1, 2, . . . , n − 1, (16.20)
n−1

n−2 n−3
Z b " #
h X X
f (x) dx ≈ f (x0 ) + 4 f (xi ) + 2 f (xi ) + f (xn−1 ) (16.21)
a 3 i=1 i=2
i ímpar i par

onde:
• f (x0 ) e f (xn−1 ) são os valores nos extremos do intervalo;
• os pontos de índice ímpar (excluindo os extremos) recebem peso 4;
• os pontos de índice par (excluindo os extremos) recebem peso 2.

Exemplo para n = 9 (ou seja, 8 subintervalos e 9 pontos igualmente espaçados), a forma

expandida da Equação 16.21 será:
Z b
hh i
f (x) dx ≈ f (x0 ) + 4f (x1 ) + 2f (x2 ) + 4f (x3 ) + 2f (x4 ) + 4f (x5 ) + 2f (x6 ) + 4f (x7 ) + f (x8 )
a 3

y
2
2 4 4
2 2

1.5 4 4
bloco 2 (2 h)
1 1
1

0.5 bloco 1 (2 h)

x
0.5 1 1.5 2 2.5 3

Figura 16.6: Ilustração da Regra de Simpson 1/3 Composta com n = 9 pontos (8

subintervalos), mostrando os blocos de comprimento 2h. Os coeficientes de ponderação
estão indicados sobre os pontos: 1 nos extremos, 4 nos pontos de índice ímpar e 2 nos
pontos de índice par, de acordo com a fórmula da regra composta.
16.7 Método de Simpson 1/3 Composta 209

Exemplo: 11
Calcule a aproximação da seguinte integral 16.19 usando a regra de Simpson 1/3 com 3 e 9 pontos.
Z 1
x3 dx
0

Solução: Considerando n = 3 o número de pontos, o total de intervalos será n − 1. Então:

b−a 1−0 1
h= = = = 0.5
n−1 3−1 2
Logo meus pontos serão:

x 0 0.5 1
f (x) 0 0.125 1

Agora vamos aplicar a equacao 16.19:

h
h i
I(f ) ≈ f (x0 ) + 4f (x1 ) + f (x2 )
3
0.5
h i
≈ 0 + 4(0.125) + 1
3

≈ 0.25

Solução: Com n = 9 (número de pontos), o número de subintervalos é n − 1 = 8 (par), então a

regra composta é aplicável. Logo,
b−a 1−0 1
h= = = = 0.125
n−1 9−1 8
Os pontos e valores da função são:

xi 0 0.125 0.25000 0.37500 0.50000 0.62500 0.75000 0.87500 1

f (xi ) 0 0.00195 0.01562 0.05273 0.12500 0.24414 0.42188 0.66992 1

Aplicando a fórmula composta (com i ímpares: pesos 4; i pares internos: pesos 2):
7 6
h
h X X i
I(f ) ≈ f (x0 ) + 4 f (xi ) + 2 f (xi ) + f (x8 )
3
i=1 i=2
i ímpar i par

0.12500
h
= 0 + 4(0.00195 + 0.05273 + 0.24414 + 0.66992)
3 i
+2(0.01562 + 0.12500 + 0.42188) + 1

0.12500
h i
= 4(0.96874) + 2(0.56250) + 1
3
0.12500
= (5.99996) ≈ 0.25000.
3
Z 1
Observação: o valor exato de x3 dx é 1
4 = 0.25000, portanto a aproximação coincide com o
0
valor exato neste caso.
 210 Capítulo 16. Integração Numérica

Folha de Exercício 37: [Solução da Folha de Exercício 37]

R2
15. Calcule a integral 0 sin(x2 ) dx com n = 50 trapézios. Essa
1. Use o método dos trapézios para aproximar a integral de- integral não tem solução elementar.
finida da função f (x) = x2 no intervalo [0, 2] com n = 4 R3 x2
subintervalos. 16. Calcule 0
e− 2 dx numericamente pelo método dos trapé-
zios.
2. Implemente em Python uma função que calcule a integral
definida de f (x) = sin(x) no intervalo [0, π] usando o método 17. Implemente em Python uma função que calcule a integral
Rb
dos trapézios. Teste com n = 10. f (x) dx via trapézios e compare os resultados para dife-
a
3. Calcule numericamente a integral da função f (x) = ex em rentes n com o valor exato, para f (x) = x3 em [0, 2].
[0, 1] com n = 5 usando o método dos trapézios. Compare o 18. Use o método dos trapézios para calcular a integral
resultado com a solução analítica e − 1. R π/4
0
tan(x) dx. Compare com o valor exato ln(cos(0)) −
4. A corrente elétrica em um circuito varia com o tempo se- ln(cos(π/4)).
gundo i(t) = 5te−t . Calcule numericamente a carga total R4
transferida no intervalo [0, 5] usando o método dos trapézios 19. Calcule a integral 0 f (x) dx usando o método dos trapé-
com n = 20. zios para a função dada pelos seguintes pontos tabelados
uniformemente espaçados: (0, 2), (1, 3), (2, 5), (3, 4), (4, 2).
5. Implemente em Python uma rotina que calcule a integral
R 10 20. A velocidade v(t) (em m/s) de um veículo foi medida a cada 2
cos(x2 ) dx pelo método dos trapézios. Essa integral não
0 segundos, resultando na seguinte tabela: t = [0, 4, 7, 8, 10, 15]
tem solução analítica elementar.
√ e v = [0, 15, 20, 22, 18, 0]. Estime a distância total percorrida
6. Um reservatório possui seção transversal descrita por y = x em metros usando o método dos trapézios.
no intervalo [0, 4]. Calcule a área da seção utilizando o mé-
21. Calcule a aproximação da integral para um conjunto de
todo dos trapézios com n = 16.
dados com espaçamento irregular. Os pontos medidos são:
7. Implemente em Python um programa que calcule a integral x = [0, 1.1, 2.2, 4.7, 5.3] e f (x) = [1.0, 3.0, 2.0, 4.0, 1.0].
R π/2
0
ln(cos(x)) dx pelo método dos trapézios. Essa integral 22. A largura L(y) de um rio (em metros) foi medida em inter-
não é elementar. valos de 5 metros a partir de uma das margens, gerando
8. Em física nuclear, a função de decaimento radioativo a tabela: y = [0, 3, 10, 12, 24], L = [0, 8, 12, 9, 0]. Estime a
é N (t) = N0 e−λt . Calcule numericamente a integral área da superfície do rio nesse trecho utilizando a regra dos
R 10
N (t) dt para N0 = 1000 e λ = 0.1. trapézios.
0
R 3 sin(x) sin(0) 23. A força F (x) (em N) aplicada a um objeto em função da sua
9. Calcule numericamente a integral 0 x dx (com 0 = posição x (em m) foi registrada como: x = [0, 0.3, 1.5, 1.7, 2.9],
1). Essa integral não tem solução elementar. F = [10,
R 12, 15, 10, 5]. Calcule o trabalho total realizado
10. Implemente em Python um programa que plote a conver- W = F (x) dx.
gência do método dos trapézios em função do número de 24. Escreva um script em Python que utilize a função
subintervalos para f (x) = cos(x) em [0, π/2]. [Link] para calcular a área sob a curva dada pelos ar-
11. Em termodinâmica, a energia interna pode ser escrita rays de dados experimentais x = [0, 1, 3.5, 4.9, 6.6]
como U = Cv (T ) dT . Considere Cv (T ) = 25 + 0.01T para e y = [2.5, 3.0, 4.5, 2.0, 1.0].
R
T ∈ [300, 600]. Calcule U numericamente. 25. Implemente em Python uma função trapezios_tabela(x,
12. Implemente em Python um programa que calcule y) que receba duas listas de pontos (assuma que podem
R 1 −x2
e cos(x) dx pelo método dos trapézios. não ser equidistantes) e retorne a integral calculada pelo
0 método dos trapézios, sem utilizar bibliotecas externas de
R4√
13. Calcule 0 x + 1 dx usando o método dos trapézios com integração.
n = 8. 26. A taxa de fluxo volumétrico Q(t) (em m3/min) em
14. Implemente em Python uma rotina que estime a integral uma tubulação foi registrada nos instantes t (em min):
(0, 0.5), (2, 1.2), (5, 1.5), (7, 0.8), (10, 0.2). Calcule o volume
R ∞ −x
0
e dx truncando o intervalo em [0, 10].
total escoado nestes 10 minutos.
 16.7 Método de Simpson 1/3 Composta 211

Folha de Exercício 38: [Solução da Folha de Exercício 38]

1. Use o método de Simpson 1/3 (composto) para aproximar Simpson 1/3 em f (x) = cos x no intervalo [0, π/2], mostrando
a integral de f (x) = x2 no intervalo [0, 2] com n = 5. o decaimento do erro em função de n.
R1√
2. Implemente em Python uma função simpson13(a,b,n) que 14. Estime 0 1 − x2 dx por Simpson 1/3 e compare com π/4.
Rb
calcule a f (x) dx via Simpson 1/3 composto. Teste com Comente o desempenho versus a regra dos trapézios para os
f (x) = sin x em [0, π]. A função deve retornar um erro caso mesmos n.
n seja par. 15. Em escoamento laminar, o perfil é v(y) = 4y(1 − y), y ∈ [0, 1].
R1 R1
x
3. Aproxime numericamente 0 e dx usando Simpson 1/3 com Calcule a vazão Q = 0 v(y) dy com Simpson 1/3 usando
n = 7. Compare com o valor exato e − 1 (1.71828182845905) n = 9 e compare com o valor exato.
e estime o erro absoluto. R5 2
16. Calcule 0 e−x dx com Simpson 1/3 para n = 97 e compare
R5 √
4. Em um circuito RC, a carga total transferida é Q = 0 i(t) dt, com 0.5 π erf(5). Discuta a escolha do intervalo finito.
com i(t) = 5te−t . Calcule Q por Simpson 1/3 com n = 13 e R3
compare a diferença para a regra dos trapézios com o mesmo 17. Estime 1 1
x dx por Simpson 1/3 com n = 7 e compare com
n. ln 3 − ln 1.
18. O trabalho de uma força F (x) = 2x2 + 3x ao longo de [0, 4]
R 10
5. Calcule numericamente 0 cos(x2 ) dx (integral de Fresnel) R4
com Simpson 1/3 para n = 17. Explore a sensibilidade do é W = 0 F (x) dx. Calcule W via Simpson 1/3 com n = 13.
resultado variando n. Rπ
R1 19. Compute numericamente 0 | sin x| dx por Simpson 1/3 com
6. Use Simpson 1/3 para aproximar 0 1+x 1
2 dx com n = 7 e n = 37. Compare com o valor exato 2.
compare com a solução 0.785398163397448.
20. Em termodinâmica, U = Cv (T ) dT . Para Cv (T ) = 25 +
R
√
7. A seção de um reservatório é dada por y = x para x ∈ [0, 4]. 0.01T em [300, 600], estime U com Simpson 1/3 usando
R4√
Estime a área 0 x dx via Simpson 1/3 com n = 15 e com- n = 13.
pare com o valor analítico. R1 2
21. Implemente em Python Simpson 1/3 para 0 e−x cos x dx
8. Implemente em Python a integração por Simpson 1/3 para e estude a convergência com n = 7, 13, 21, 111.
R π/2
ln(cos x) dx. Avalie a integral com n = 17. R4√
0 22. Estime 0 x + 1 dx por Simpson 1/3 com n = 13 e compare
com a solução analítica 2[(x + 1)3/2 /3]40 .
R2
9. Calcule 0 (x3 + 2x) dx por Simpson 1/3 com n = 5. Com-
pare com o valor exato 6 e estime o erro relativo. 23. Implemente em Python Simpson 1/3 para aproximar
R ∞ −x
10. Em decaimento radioativo, N (t) = N0 e−λt . Estime 0
e dx em [0, 10]. Compare com o valor exato 1 e analise
R 10 o erro de truncamento.
0
N (t) dt para N0 = 1000, λ = 0.1 via Simpson 1/3 com R2
n = 37. 24. Aproxime 0
sin(x2 ) dx com Simpson 1/3 para n = 99.
11. Escreva um programa em Python usando Simpson 1/3 para R3 2
25. Calcule 0 e−x /2 dx por Simpson 1/3 com n = 21 e compare
2
f (x) = e−x em [0, 2], usando n = 11. √
com
pπ
R3 2 erf(3/ 2).
12. Aproxime 0 sinx x dx por Simpson 1/3, tratando f (0) = 1. R π/4
Avalie a convergência com n = 13. 26. Estime 0 tan x dx por Simpson 1/3 com n = 21 e compare
com ln(cos 0) − ln(cos(π/4)).
13. Implemente em Python um estudo de convergência para
 17. Derivação Numérica

17.1 Introdução
Métodos Numéricos para Aproximação de Derivadas
1. Diferenças Finitas

f (x + h) − f (x)
Forward difference: f ′ (x) ≈ O(h)
h
(17.1)
f (x) − f (x − h)
Backward difference: f ′ (x) ≈ O(h)
h
(17.2)
f (x + h) − f (x − h)
Central difference: f ′ (x) ≈ O(h2 )
2h
(17.3)
−f (x + 2h) + 8f (x + h) − 8f (x − h) + f (x − 2h)
4ª ordem: f ′ (x) ≈ O(h4 )
12 h
(17.4)

2. Extrapolação de Richardson

f (x + h) − f (x − h)
D(h) = = f ′ (x) + c2 h2 + c4 h4 + · · · , (17.5)
2h
4 D(h/2) − D(h)
DR (h) = = f ′ (x) + O(h4 ) (17.6)
4−1

3. Interpolação Polinomial
Polinômio de Lagrange
n n
X Y x − xj
Pn (x) = yi Li (x), Li (x) = ,
i=0 j=0
xi − xj
j̸=i
214 Capítulo 17. Derivação Numérica
n
f ′ (x) ≈ Pn′ (x) = yi L′i (x),
X

i=0

onde
n n
!
x − xj 1
L′i (x)
X Y
= .
k=0 j=0
xi − xj xi − xk
k̸=i j̸=i,k

Spline Cúbica

f ′ (x) ≈ S ′ (x),

onde S(x) é o spline cúbico ajustado aos pontos (xi , yi ).

4. Método do Complex-Step


′ ℑ f (x + i h)
f (x) ≈ , O(h2 ),
h
com h muito pequeno (e.g. 10−20 ).

5. Diferenciação Automática (AD)

• Rastreia analiticamente cada operação elementar.
• Fornece derivadas exatas até o erro de máquina.
• Implementado em bibliotecas como JAX, TensorFlow e PyTorch.
Bibliography
Bibliografia

[1] amigoproducoeseterno. 24 AVASSALADORES wmv. YouTube. 12 de ago. de 2010.

url: [Link] (acesso em 17/05/2025)
(ver página 19).
[2] Leo Geurts, Lambert Meertens e Steven Pemberton. ABC programmer’s handbook.
USA: Prentice-Hall, Inc., 1990. isbn: 0130000272 (ver página 18).
[3] Charles R Harris et al. “Array programming with NumPy”. Em: Nature 585.7825
(2020), páginas 357–362. doi: 10.1038/s41586-020-2649-2 (ver página 18).
[4] John D. Hunter. “Matplotlib: A 2D Graphics Environment”. Em: Computing in
Science & Engineering 9.3 (2007), páginas 90–95. doi: 10.1109/MCSE.2007.55 (ver
página 18).
[5] Python Software Foundation. IDLE: Integrated Development and Learning Envi-
ronment. [Link] Acessado em: 6 de
Outubro de 2025. 2025 (ver página 24).
[6] “IEEE Standard for Floating-Point Arithmetic”. Em: IEEE Std 754-2019 (Revision
of IEEE 754-2008) (2019), páginas 1–84. doi: 10.1109/IEEESTD.2019.8766229 (ver
páginas 129, 130).
[7] Project Jupyter. Project Jupyter: Jupyter Notebook. [Link] Aces-
sado em: 6 de Outubro de 2025. 2025 (ver página 24).
[8] José Matos. “Erros de Matemática Podem Levar ao Desastre”. Em: Gazeta de
Matemática 171 (2012). Instituto Superior de Engenharia do Porto, páginas 42–48.
url: [Link] (ver página 134).
[9] Matplotlib Development Team. Matplotlib Documentation. Accessed: 2025-05-17.
2025. url: [Link] (ver página 18).
[10] DACC - IF Sudeste MG. Usando o Ambiente IDLE - Curso Python Para Quem Tem
Pressa (Aula 3). Vídeo disponível no YouTube. Acesso em 21 maio 2025. 2011. url:
[Link] (ver página 20).
218 BIBLIOGRAFIA

[11] Monty Python. Monty Python’s Flying Circus. Programa de televisão. Produzido
pela BBC Television, Reino Unido. Criado por Graham Chapman, John Cleese,
Terry Gilliam, Eric Idle, Terry Jones e Michael Palin. 1969. url: https : / / en .
[Link]/wiki/Monty_Python%27s_Flying_Circus (acesso em 16/05/2025)
(ver página 18).
[12] NumPy Developers. NumPy Documentation. Accessed: 2025-05-17. 2025. url: https:
//[Link]/doc/ (ver página 18).
[13] JetBrains. PyCharm: The Python IDE for Professional Developers. [Link]
[Link]/pt-br/pycharm/. Acessado em: 6 de Outubro de 2025. 2025 (ver
página 24).
[14] Python Package Index (PyPI). Python Package Index. [Link]
wiki/Python_Package_Index. Acessado em 24 de junho de 2025. Registrado como
tendo mais de 530000 pacotes em maio de 2024. 2024 (ver página 47).
[15] Python Software Foundation. The Python Standard Library: math - Mathematical
Functions. Available at [Link] Python
Software Foundation. 2024. url: [Link]
html (ver página 18).
[16] Python Software Foundation. Download Python. Página oficial de distribuição da
linguagem Python. 2025. url: [Link] (acesso em
16/05/2025) (ver página 19).
[17] Spyder Development Team. Spyder: The Scientific Python Development Environment.
[Link] Acessado em: 6 de Outubro de 2025. 2025 (ver
página 24).
[18] Thonny Team. Thonny: Python IDE for beginners. [Link] Acessado
em: 6 de Outubro de 2025. 2025 (ver página 24).
[19] Microsoft. Visual Studio Code: Code Editing. Redefined. https : / / code .
[Link]/. Acessado em: 6 de Outubro de 2025. 2025 (ver página 24).
[20] Wikipédia. Álgebra booliana. Acesso em: 22 de maio de 2025. 2025. url: https:
//[Link]/wiki/%C3%81lgebra_booliana (ver página 31).
[21] Wikipédia. Depuração. Acesso em: 22 de maio de 2025. 2025. url: [Link]
[Link]/wiki/Depura%C3%A7%C3%A3o (ver página 34).
BIBLIOGRAFIA 219

–––––––––––––––––––––––––––––––––––––-
LOG - DEPURAÇÃO - LaTeX
prof. Carlos Wilson
Ciência da Computação - UFCG
–––––––––––––––––––––––––––––––––––––-

Última atualização_____________: 27 de abril de 2026 às 08:47

Número de compilação___________: 100.6575
Tempo de compilação padrão:____: 22seg
Tempo de compilação atual______: 21seg
18. Resolução do exercício

Resolução: Folha de Exercício 1.

[Voltar à Folha de Exercício 1]
1. Segue o código Python:
1 print ( " Lucas Ribeiro de Almeida " )

2. Segue o código Python:

1 print ( " Lucas Ribeiro de Almeida " )

3. Segue o código Python:

1 celsius = float ( input ( " Informe a temperatura em graus Celsius : " ) )
2 fahrenheit = celsius * (9.0 / 5.0) + 32
3 print ( " Conversao : %.2 f graus Celsius para Fahrenheit : %.2 f " % ( celsius ,
fahrenheit ) )

4. Segue o código Python:

1 valor = float ( input ( " Informe o valor do produto : " ) )
2 desconto = valor * 0.12
3 va lor_com_desconto = valor - desconto
4 print ( " O valor do produto com desconto : %.2 f " % valor_com_desconto )

5. Sol questao 5
6. Sol questao 6
7. Sol questao 7
8. Sol questao 8
9. Sol questao 9
10. Sol questao 10
11. Sol questao 11

Resolução: Folha de Exercício 2.

[Voltar à Folha de Exercício 2]
1. sol questao 1
2. Sol questao 2
3. Sol questao 3
222 Capítulo 18. Solução

4. Sol questao 4
5. Sol questao 5
6. Sol questao 6
7. Sol questao 7
8. Sol questao 9
9. Sol questao 9
10. Sol questao 10
11. Sol questao 11
12. Sol questao 12
13. Sol questao 13
14. Sol questao 14
15. Sol questao 2
16. Sol questao 2
17. Sol questao 2
18. Sol questao 2
19. Sol questao 2
20. Sol questao 2
21. Sol questao 2
22. Sol questao 2

Resolução: Folha de Exercício 3.

[Voltar à Folha de Exercício 3]
1. sol questao 1
2. Sol questao 2
3. Sol questao 3
4. Sol questao 4
5. Sol questao 5
6. Sol questao 6
7. Sol questao 7
8. Sol questao 9
9. Sol questao 9
10. Sol questao 10
11. Sol questao 11
12. Sol questao 12
13. Sol questao 13
14. Sol questao 14
15. Sol questao 2
16. Sol questao 2
17. Sol questao 2
18. Sol questao 2
19. Sol questao 2
20. Sol questao 2
21. Sol questao 2
22. Sol questao 2

Resolução: Folha de Exercício 4.

[Voltar à Folha de Exercício 4]
1. sol questao 1
 223

2. Sol questao 2
3. Sol questao 3
4. Sol questao 4
5. Sol questao 5
6. Sol questao 6
7. Sol questao 7
8. Sol questao 8
9. Sol questao 9
10. Sol questao 10
11. Sol questao 11
12. Sol questao 12
13. Sol questao 13
14. Solução Folha 04, Questão 14

Resolução: Folha de Exercício 5.

[Voltar à Folha de Exercício 5]
1. Solução Folha 05, Questão 01
2. Solução Folha 05, Questão 02
3. Solução Folha 05, Questão 03
4. Solução Folha 05, Questão 04
5. Solução Folha 05, Questão 05
6. Solução Folha 05, Questão 06
7. Solução Folha 05, Questão 16
8. Solução Folha 05, Questão 08
9. Solução Folha 05, Questão 09
10. Solução Folha 05, Questão 10
11. Solução Folha 05, Questão 11
12. Solução Folha 05, Questão 12
13. Solução Folha 05, Questão 13
14. Solução Folha 05, Questão 14
15. Solução Folha 05, Questão 15

Resolução: Folha de Exercício 6.

[Voltar à Folha de Exercício 6]
1. Solução Folha 05, Questão 01
2. Solução Folha 05, Questão 02
3. Solução Folha 05, Questão 03
4. Solução Folha 05, Questão 04
5. Solução Folha 05, Questão 05
6. Solução Folha 05, Questão 06
7. Solução Folha 05, Questão 16
8. Solução Folha 05, Questão 08
9. Solução Folha 05, Questão 09
10. Solução Folha 05, Questão 10
11. Solução Folha 05, Questão 11
12. Solução Folha 05, Questão 12
13. Solução Folha 05, Questão 13
14. Solução Folha 05, Questão 14
224 Capítulo 18. Solução

15. Solução Folha 05, Questão 15

Resolução: Folha de Exercício 7.

[Voltar à Folha de Exercício 7]
1. Solução Folha 06, Questão 01
2. Solução Folha 06, Questão 02
3. Solução Folha 06, Questão 03
4. Solução Folha 06, Questão 04
5. Solução Folha 06, Questão 05
6. Solução Folha 06, Questão 06
7. Solução Folha 06, Questão 07
8. Solução Folha 06, Questão 08
9. Solução Folha 06, Questão 09
10. Solução Folha 06, Questão 10
11. Solução Folha 06, Questão 11
12. Solução Folha 06, Questão 12
13. Solução Folha 06, Questão 13
14. Solução Folha 06, Questão 14
15. Solução Folha 06, Questão 15
16. Solução Folha 06, Questão 16
17. Solução Folha 06, Questão 17
18. Solução Folha 06, Questão 18
19. Solução Folha 06, Questão 19
20. Solução Folha 06, Questão 20
21. Solução Folha 06, Questão 21
22. Solução Folha 06, Questão 22
23. Solução Folha 06, Questão 23
24. Solução Folha 06, Questão 24
25. Solução Folha 06, Questão 25
26. Solução Folha 06, Questão 26
27. Solução Folha 06, Questão 27
28. Solução Folha 06, Questão 28
29. Solução Folha 06, Questão 29
30. Solução Folha 06, Questão 30
31. Solução Folha 06, Questão 31
32. Solução Folha 06, Questão 32

Resolução: Folha de Exercício 8.

[Voltar à Folha de Exercício 8]
1. Solução Folha 07, Questão 01
2. Solução Folha 07, Questão 02
3. Solução Folha 07, Questão 03
4. Solução Folha 07, Questão 04
5. Solução Folha 07, Questão 05
6. Solução Folha 07, Questão 06
7. Solução Folha 07, Questão 07
8. Solução Folha 07, Questão 08
9. Solução Folha 07, Questão 09
 225

10. Solução Folha 07, Questão 10

11. Solução Folha 07, Questão 11
12. Solução Folha 07, Questão 12
13. Solução Folha 07, Questão 13
14. Solução Folha 07, Questão 14

Resolução: Folha de Exercício 9.

[Voltar à Folha de Exercício 9]
1. Solução Folha 09, Questão 01
2. Solução Folha 09, Questão 02
3. Solução Folha 09, Questão 03
4. Solução Folha 09, Questão 04
5. Solução Folha 09, Questão 05
6. Solução Folha 09, Questão 06
7. Solução Folha 09, Questão 07
8. Solução Folha 09, Questão 08
9. Solução Folha 09, Questão 09
10. Solução Folha 09, Questão 10
11. Solução Folha 09, Questão 11
12. Solução Folha 09, Questão 12
13. Solução Folha 09, Questão 13
14. Solução Folha 09, Questão 14
15. Solução Folha 09, Questão 15
16. Solução Folha 09, Questão 16
17. Solução Folha 09, Questão 17
18. Solução Folha 09, Questão 18
19. Solução Folha 09, Questão 19
20. Solução Folha 09, Questão 20
21. Solução Folha 09, Questão 21
22. Solução Folha 09, Questão 22
23. Solução Folha 09, Questão 23
24. Solução Folha 09, Questão 24
25. Solução Folha 09, Questão 25
26. Solução Folha 09, Questão 26
27. Solução Folha 09, Questão 27
28. Solução Folha 09, Questão 28
29. Solução Folha 09, Questão 29
30. Solução Folha 09, Questão 30
31. Solução Folha 09, Questão 31
32. Solução Folha 09, Questão 32
33. Solução Folha 09, Questão 33

Resolução: Folha de Exercício 10.

[Voltar à Folha de Exercício 10]
1. Solução Folha 10, Questão 01
2. Solução Folha 08, Questão 02
3. Solução Folha 08, Questão 03
4. Solução Folha 08, Questão 04
226 Capítulo 18. Solução

5. Solução Folha 08, Questão 05

6. Solução Folha 08, Questão 06
7. Solução Folha 08, Questão 07
8. Solução Folha 08, Questão 08
9. Solução Folha 08, Questão 09
10. Solução Folha 08, Questão 10
11. Solução Folha 08, Questão 11
12. Solução Folha 08, Questão 12
13. Solução Folha 08, Questão 13
14. Solução Folha 08, Questão 14
15. Solução Folha 08, Questão 15
16. Solução Folha 08, Questão 16
17. Solução Folha 08, Questão 17
18. Solução Folha 08, Questão 18
19. Solução Folha 08, Questão 19
20. Solução Folha 08, Questão 20
21. Solução Folha 08, Questão 21

Resolução: Folha de Exercício 11.

[Voltar à Folha de Exercício 11]
1. Solução Folha 09, Questão 01
2. Solução Folha 09, Questão 02
3. Solução Folha 09, Questão 03
4. Solução Folha 09, Questão 04
5. Solução Folha 09, Questão 05
6. Solução Folha 09, Questão 06
7. Solução Folha 09, Questão 07
8. Solução Folha 09, Questão 08
9. Solução Folha 09, Questão 09
10. Solução Folha 09, Questão 10
11. Solução Folha 09, Questão 11
12. Solução Folha 09, Questão 12
13. Solução Folha 09, Questão 13
14. Solução Folha 09, Questão 14
15. Solução Folha 09, Questão 15
16. Solução Folha 09, Questão 16

Resolução: Folha de Exercício 12.

[Voltar à Folha de Exercício 12]
1. Solução Folha 09, Questão 01
2. Solução Folha 09, Questão 02
3. Solução Folha 09, Questão 03
4. Solução Folha 09, Questão 04
5. Solução Folha 09, Questão 05
6. Solução Folha 09, Questão 06
7. Solução Folha 09, Questão 07
8. Solução Folha 09, Questão 08
9. Solução Folha 09, Questão 09
 227

10. Solução Folha 09, Questão 10

11. Solução Folha 09, Questão 11
12. Solução Folha 09, Questão 12
13. Solução Folha 09, Questão 13
14. Solução Folha 09, Questão 14
15. Solução Folha 09, Questão 15
16. Solução Folha 09, Questão 16

Resolução: Folha de Exercício 13.

[Voltar à Folha de Exercício 13]
1. Solução Folha 13, Questão 01
2. Solução Folha 13, Questão 02
3. Solução Folha 13, Questão 03
4. Solução Folha 13, Questão 04
5. Solução Folha 13, Questão 05
6. Solução Folha 13, Questão 06
7. Solução Folha 13, Questão 07
8. Solução Folha 13, Questão 08
9. Solução Folha 13, Questão 09
10. Solução Folha 13, Questão 10
11. Solução Folha 13, Questão 11
12. Solução Folha 13, Questão 12
13. Solução Folha 13, Questão 13
14. Solução Folha 13, Questão 14
15. Solução Folha 13, Questão 15
16. Solução Folha 13, Questão 16
17. Solução Folha 13, Questão 17
18. Solução Folha 13, Questão 18
19. Solução Folha 13, Questão 19
20. Solução Folha 13, Questão 20
21. Solução Folha 13, Questão 21
22. Solução Folha 13, Questão 22
23. Solução Folha 13, Questão 23
24. Solução Folha 13, Questão 24
25. Solução Folha 13, Questão 25
26. Solução Folha 13, Questão 26
27. Solução Folha 13, Questão 27
28. Solução Folha 13, Questão 28
29. Solução Folha 13, Questão 29
30. Solução Folha 13, Questão 30
31. Solução Folha 13, Questão 31
32. Solução Folha 13, Questão 32
33. Solução Folha 13, Questão 33
34. Solução Folha 13, Questão 34
35. Solução Folha 13, Questão 35
36. Solução Folha 13, Questão 36
37. Solução Folha 13, Questão 37
38. Solução Folha 13, Questão 38
228 Capítulo 18. Solução

39. Solução Folha 13, Questão 39

40. Solução Folha 13, Questão 40

Resolução: Folha de Exercício 14.

[Voltar à Folha de Exercício 14]
1. Solução Folha 14, Questão 01
2. Solução Folha 14, Questão 02
3. Solução Folha 14, Questão 03
4. Solução Folha 14, Questão 04
5. Solução Folha 14, Questão 05
6. Solução Folha 14, Questão 06
7. Solução Folha 14, Questão 07
8. Solução Folha 14, Questão 08
9. Solução Folha 14, Questão 09
10. Solução Folha 14, Questão 10
11. Solução Folha 14, Questão 11
12. Solução Folha 14, Questão 12
13. Solução Folha 14, Questão 13
14. Solução Folha 14, Questão 14
15. Solução Folha 14, Questão 15
16. Solução Folha 14, Questão 16
17. Solução Folha 14, Questão 17
18. Solução Folha 14, Questão 18
19. Solução Folha 14, Questão 19
20. Solução Folha 14, Questão 20

Resolução: Folha de Exercício 15.

[Voltar à Folha de Exercício 15]
1. Solução Folha 15, Questão 01
2. Solução Folha 15, Questão 02
3. Solução Folha 15, Questão 03
4. Solução Folha 15, Questão 04
5. Solução Folha 15, Questão 05
6. Solução Folha 15, Questão 06
7. Solução Folha 15, Questão 07
8. Solução Folha 15, Questão 08
9. Solução Folha 15, Questão 09
10. Solução Folha 15, Questão 10

Resolução: Folha de Exercício 16.

[Voltar à Folha de Exercício 16]
1. Considere os valores seed=10 e n=3.
A solução obtida será: EM A = 0.398855869.
Segue o código Python:
1 import numpy
2 n = int ( input ( " Informe o valor de n : " ) )
3 numpy . random . seed (10) # define a semente
4 F = numpy . random . rand (n , n )
5 G = numpy . random . rand (n , n )
6 soma_EMQ = 0
 229

7
8 for i in range (0 ,n ,1) :
9 for j in range (0 ,n ,1) :
10 soma_EMQ += ( F [i , j ] - G [i , j ]) **2
11
12 sol_EMQ = soma_EMQ / ( n **2)
13 print ( " O erro Medio Absoluto ( EMQ ) : %.9 f " %( sol_EMQ ) )

2. Considere os valores seed=10 e n=3.

A solução obtida será: EM Q = 0.233254728.
3. Considere os valores seed=10 e n=3.
A solução obtida será: EM QN = 0.838757270.
4. Considere os valores seed=10 e n=3.
A solução obtida será: EM AR = 4.435886123.
5. Considere os valores seed=10 e n=3.
A media da Matriz F: 0.447281420.
A media da Matriz G: 0.520223547.
6. Considere os valores seed=10 e n=3.
Desvio Absoluto Medio de F (DAM): 0.261422974.
Desvio Absoluto Medio de G (DAM): 0.263230617.
7. Considere os valores seed=10 e n=3.
Variancia de F: 0.078034957.
Variancia de G: 0.094978658.
8. Considere os valores seed=10 e n=3.
Covariancia entre F e G: −0.027460280
9. Considere os valores seed=10 e n=3.
Coeficiente de Correlacao entre F e G: −0.318968172.

Resolução: Folha de Exercício 17.

[Voltar à Folha de Exercício 17]
1. Sol questao 10
2. Sol questao 11
3. Sol questao 3
4. Sol questao 4
5. Sol questao 5
6. Sol questao 6
7. Sol questao 7
8. Sol questao 8

Resolução: Folha de Exercício 18.

[Voltar à Folha de Exercício 18]
1. Sol questao 9
2. sol questao 1
3. Sol questao 2
4. Sol questao 4
5. Sol questao 5
6. Sol questao 6

Resolução: Folha de Exercício 19.

[Voltar à Folha de Exercício 19]
230 Capítulo 18. Solução

1. Segue o código Python:

1 celsius = float ( input ( " Informe a temperatura em graus Celsius : " ) )
2 fahrenheit = celsius * (9.0 / 5.0) + 32
3 print ( " Conversao : %.2 f graus Celsius para Fahrenheit : %.2 f " % ( celsius ,
fahrenheit ) )

2. Sol questao 4
3. Sol questao 5
4. Sol questao 9
5. Sol questao 13

Resolução: Folha de Exercício 20.

[Voltar à Folha de Exercício 20]
1. sol questao 1
2. Sol questao 2
3. Sol questao 3
4. Sol questao 4
5. Sol questao 9
6. Sol questao 10
7. Sol questao 11
8. Sol questao 12
9. Sol questao 13
10. Sol questao 14
11. Sol questao X
12. Sol questao X

Resolução: Folha de Exercício 21.

[Voltar à Folha de Exercício 21]

Resolução: Folha de Exercício 22.

[Voltar à Folha de Exercício 22]
1. sol questao 1
2. Sol questao 2
3. Sol questao 3
4. Sol questao 4
5. Sol questao 5
6. Sol questao 6
7. Sol questao 7
8. Sol questao 8
9. Sol questao 9

Resolução: Folha de Exercício 23.

[Voltar à Folha de Exercício 23]
1. sol questao 1
2. Sol questao 2
3. Sol questao 3
4. Sol questao 4
5. Sol questao 5
6. Sol questao 6
7. Sol questao 7
 231

8. Sol questao 8
9. Sol questao 9
10. Sol questao 10

Resolução: Folha de Exercício 24.

[Voltar à Folha de Exercício 24]
1. sol questao 1
2. Sol questao 2
3. Sol questao 3
4. Sol questao 4
5. Sol questao 5
6. Sol questao 6
7. Sol questao 7
8. Sol questao 8
9. Sol questao 9
10. Sol questao 10
11. Sol questao 12
12. Sol questao 13

Resolução: Folha de Exercício 25.

[Voltar à Folha de Exercício 25]

1. Após a realização de cinco iterações do método da bisseção para a função f (x) = cos(x) − x,
no intervalo inicial [0, 1], a aproximação para a raiz da equação é xc ≈ 0.71875.

2. O método da falsa posição irá atingir a convergência após 25 iterações. A solução encontrada
será xr ≈ 1.35730636886233, com um erro relativo de εrel ≈ 7.417540 × 10−5 .

3. Após a conclusão de cinco iterações do método da secante, a aproximação para a raiz é obtida
como: ≈ 0.567143290409705
4. Após a conclusão de cinco iterações do método da secante modificada, a aproximação para a
raiz é obtida como: ≈ 1.414215047848775
5. Sol questao 5
6. Sol questao 6
7. Sol questao 7
8. Sol questao 8
9. Sol questao 9
10. Sol questao 10
11. Sol questao 11
12. Sol questao 12
13. Sol questao 13
14. Sol questao 14
15. Sol questao 15
16. Sol questao 16
17. Sol questao 17
18. Sol questao 18
19. Sol questao 19
20. Sol questao 20
232 Capítulo 18. Solução

21. Sol questao 21

22. Sol questao 22
23. Sol questao 23
24. Sol questao 24
25. Sol questao 25
26. Sol questao 26
27. Sol questao 27
28. Sol questao 28
29. Sol questao 29
30. Sol questao 30

Resolução: Folha de Exercício 26.

[Voltar à Folha de Exercício 26]
1. sol questao 1
2. Sol questao 2
3. Sol questao 3
4. Sol questao 4

5. Para os valores dos parâmetros fornecidos, a velocidade será igual a v = 35m/s em t = 9s para
uma massa m tal que f (m) = 0, onde:
gm  c

f (m) = v − 1 − e −( m ) t
c
Substituindo os valores conhecidos, obtemos:
9,8m  15

f (m) = 35 − 1 − e−( m )·9
15
Utilizamos os palpites iniciais xa = 50 e xb = 100, o que faz sentido, dado que o valor procurado
representa a massa do pára-quedista. Verifique que há, de fato, uma raiz neste intervalo:

f (xa ) = f (50) = 4.5287, f (xb ) = f (100) = −13.396

Como f (xa )f (xb ) < 0, existe um x entre 50 e 100 tal que f (x) = 0. A primeira aproximação
obtida pelo método da falsa posição é:
f (100)(50 − 100)
xr = 100 − = 62.6324
f (50) − f (100)
Segue o código Python:
1 import math
2
3 def f ( m ) :
4 return v - (( g * m ) / c ) * (1 - math . exp ( -( c / m ) * t ) )
5
6 v = 35
7 t = 9
8 g = 9.8
9 c = 15
10 xa = 50
11 xb = 100
12
13 for i in range (0 ,10 ,1) :
14 fxa = f ( xa )
15 fxb = f ( xb )
 233

16 xr = xb - (( fxb *( xa - xb ) ) /( fxa - fxb ) )

17 fxr = f ( xr )
18
19 if fxa * fxr < 0:
20 xb = xr
21 else :
22 xa = xr
23
24 print ( " Solucao depois de 10 iteracoes : %.14 f " % ( xr ) )

6. Segue o código Python:

1 import matplotlib . pyplot as plt
2 import numpy as np
3
4 def f ( y ) :
5 Q = 20
6 g = 9.81
7 B = 3 + y
8 Ac = (3* y ) + (( y **2) /2)
9 return 1 - ( Q **2 / ( g * Ac **3) ) * B
10
11 # Metodo Grafico
12 y_vals = np . linspace (0.5 , 2.5 , 300)
13 f_vals = f ( y_vals )
14 plt . axhline (0 , color = " gray " , linestyle = " --" )
15 plt . plot ( y_vals , f_vals , label = r " $f ( y ) $ " , color = " blue " )
16 plt . xlabel ( " y ( m ) " )
17 plt . ylabel ( " f ( y ) " )
18 plt . title ( " Metodo grafico - Profundidade critica " )
19 plt . grid ( True )
20 plt . legend ()
21 plt . show ()

7. Queremos encontrar h tal que:

πh2 (3R − h)
f (h) = − 30 = 0
6
Substituindo R = 3
πh2 (9 − h)
f (h) = − 30
6
8. Sol questao 8
9. Sol questao 9
10. Sol questao 10
11. Sol questao 11
12. Sol questao 12
13. Sol questao 13
14. Sol questao 14
15. Sol questao 15
16. Sol questao 16
17. Sol questao 17

Resolução: Folha de Exercício 27.

[Voltar à Folha de Exercício 27]
234 Capítulo 18. Solução

1. Após cinco iterações do método da bisseção, a aproximação da raiz da equação f (x) = cos(x) − x
no intervalo [0, 1] é: x ≈ 0.71875

2.

3. Após 5 iterações, obtemos uma aproximação para a raiz: x ≈ 0.5673

4. Sol questao 4
5. Sol questao 5
6. Sol questao 6
7. Sol questao 7
8. Sol questao 8
9. Sol questao 9
10. Sol questao 10
11. Sol questao 11
12. Sol questao 12
13. Sol questao 13
14. Sol questao 14
15. Sol questao 15
16. Sol questao 16
17. Sol questao 17
18. Sol questao 18
19. Sol questao 19
20. Sol questao 20
21. Sol questao 21
22. Sol questao 22
23. Sol questao 23
24. Sol questao 24
25. Sol questao 25
26. Sol questao 26
27. Sol questao 27
28. Sol questao 28
29. Sol questao 29
30. Sol questao 30

Resolução: Folha de Exercício 28.

[Voltar à Folha de Exercício 28]
1. Solução Folha 28, Questão 01
2. Solução Folha 28, Questão 02
3. Solução Folha 28, Questão 03
4. Solução Folha 28, Questão 04
5. Solução Folha 21, Questão 05
6. Solução Folha 21, Questão 06
7. Solução Folha 21, Questão 07
8. Solução Folha 21, Questão 08
9. Solução Folha 21, Questão 09
10. Solução Folha 21, Questão 10

Resolução: Folha de Exercício 29.

 235

[Voltar à Folha de Exercício 29]

1. Solução Folha 21, Questão 11

2. Solução Folha 21, Questão 12
3. Solução Folha 21, Questão 13
4. Solução Folha 21, Questão 14
5. Solução Folha 21, Questão 15
6. Solução Folha 21, Questão 16
7. Solução Folha 21, Questão 17
8. Solução Folha 21, Questão 18
9. Solução Folha 21, Questão 19
10. Solução Folha 21, Questão 20

Resolução: Folha de Exercício 30.

[Voltar à Folha de Exercício 30]

1. O ponto de máximo local em aproximadamente (500, 183.94).

2. O ponto de máximo local em aproximadamente (1, 0.50).
3. o ponto de máximo local em aproximadamente (50, 0.50)
4. O ponto de mínimo em aproximadamente (4.64, 1392.48).
5. o ponto de máximo local em aproximadamente (20, 54.13).
6. o ponto de máximo local em aproximadamente (5, 1.8394).
7. O ponto de máximo local em aproximadamente (100, 36.79).
8. O ponto de máximo local em aproximadamente (10, 3.6788).
9. O ponto de máximo local em aproximadamente (1, 0.50).
10. O ponto de mínimo em aproximadamente (3.68, 4.07).
11. O ponto de máximo local em aproximadamente (1, 5).
12. O ponto de máximo local em aproximadamente (5, 0.6094).
13. O ponto de máximo local em aproximadamente (15, 168.02).
14. O ponto de máximo local em aproximadamente (20, 1.645).
15. O ponto de máximo local em aproximadamente (1.5208, 0.9227).

Resolução: Folha de Exercício 31.

[Voltar à Folha de Exercício 31]

1. x = 3.5, y = 7.7421666
2. x = 8, y = 10.747093795093797
3. i = 1.15, y = 0.3373
4. y = 55000, g = 9.7010
5. Sol questao 5
6. Solução Folha 32, Questão 16
7. Solução Folha 32, Questão 17
8. Solução Folha 32, Questão 18
9. Solução Folha 32, Questão 19
10. Solução Folha 32, Questão 20
11. Solução Folha 32, Questão 36
12. Solução Folha 32, Questão 37
13. Solução Folha 32, Questão 38
14. Solução Folha 32, Questão 39
15. Solução Folha 32, Questão 40
236 Capítulo 18. Solução

Resolução: Folha de Exercício 32.

[Voltar à Folha de Exercício 32]

1. Solução Folha 32, Questão 01

2. Solução Folha 32, Questão 02
3. Solução Folha 32, Questão 03
4. Solução Folha 32, Questão 04
5. Solução Folha 32, Questão 05
6. Solução Folha 32, Questão 06
7. Solução Folha 32, Questão 07
8. Solução Folha 32, Questão 08
9. Solução Folha 32, Questão 09
10. Solução Folha 32, Questão 10
11. Solução Folha 32, Questão 11
12. Solução Folha 32, Questão 12
13. Solução Folha 32, Questão 13
14. Solução Folha 32, Questão 14
15. Solução Folha 32, Questão 15

Resolução: Folha de Exercício 33.

[Voltar à Folha de Exercício 33]

1. Solução Folha 32, Questão 21

2. Solução Folha 32, Questão 22
3. Solução Folha 32, Questão 23
4. Solução Folha 32, Questão 24
5. Solução Folha 32, Questão 25
6. Solução Folha 32, Questão 26
7. Solução Folha 32, Questão 27
8. Solução Folha 32, Questão 28
9. Solução Folha 32, Questão 29
10. Solução Folha 32, Questão 30
11. Solução Folha 32, Questão 31
12. Solução Folha 32, Questão 32
13. Solução Folha 32, Questão 33
14. Solução Folha 32, Questão 34
15. Solução Folha 32, Questão 35

Resolução: Folha de Exercício 34.

[Voltar à Folha de Exercício 34]

Iteração xk1 xk2 xk3

início 0.00000 0.00000 0.00000
1. k = 1 0.90000 -2.29000 3.06700
k = 2 1.05130 -1.99843 3.00979
k = 3 0.99871 -1.99889 2.99941
 237

Iteração xk1 xk2 xk3

início 0.00000 0.00000 0.00000
k = 1 2.00000 3.00000 0.00000
2.
k = 2 2.60000 3.50000 1.66667
k = 3 3.03333 4.06667 2.03333
k = 4 3.22000 4.26667 2.36667

Iteração xk1 xk2 xk3

início 0.00000 0.00000 0.00000
k = 1 1.25000 2.70000 -1.12500
3.
k = 2 2.11250 2.96250 -1.10000
k = 3 2.17396 3.22375 -1.28281
k = 4 2.26974 3.22391 -1.26552

4. Solução Folha 34, Questão 08

Iteração xk1 xk2 xk3
início 0.00000 0.00000 0.00000
k = 1 1.33333 2.75000 -0.70000
k = 2 1.10333 2.75556 -0.70833
5.
k = 3 1.10241 2.77611 -0.75489
k = 4 1.09793 2.78395 -0.75713
k = 5 1.09726 2.78469 -0.75881
k = 6 1.09710 2.78503 -0.75902

6. Solução Folha 34, Questão 06

7. Solução Folha 34, Questão 07
8. Solução Folha 34, Questão 08
9. Solução Folha 34, Questão 09
10. Solução Folha 34, Questão 10

Resolução: Folha de Exercício 35.

[Voltar à Folha de Exercício 35]
Iteração xk1 xk2 xk3
início 0.00000 0.00000 0.00000
k = 1 1.87500 2.12500 2.05000
1. k = 2 1.86563 1.92188 2.01125
k = 3 1.88617 1.92164 2.00709
k = 4 1.88568 1.92215 2.00729
k = 5 1.88564 1.92214 2.00730

2. Solução Folha 35, Questão 03

3. Solução Folha 35, Questão 05
4. Solução Folha 35, Questão 07
5. Solução Folha 35, Questão 09
6. Solução Folha 35, Questão 11
7. Solução Folha 35, Questão 13
8. Solução Folha 35, Questão 15
9. Solução Folha 35, Questão 17
10. Solução Folha 35, Questão 19

Resolução: Folha de Exercício 36.

[Voltar à Folha de Exercício 36]

Resolução: Folha de Exercício 37.

238 Capítulo 18. Solução

[Voltar à Folha de Exercício 37]

1. Solução Folha 37, Questão 01
2. Solução Folha 37, Questão 02
3. Solução Folha 37, Questão 03
4. Solução Folha 37, Questão 04
5. Solução Folha 37, Questão 05
6. Solução Folha 37, Questão 06
7. Solução Folha 37, Questão 07
8. Solução Folha 37, Questão 08
9. Solução Folha 37, Questão 09
10. Solução Folha 37, Questão 14
11. Solução Folha 37, Questão 21
12. Solução Folha 37, Questão 22
13. Solução Folha 37, Questão 23
14. Solução Folha 37, Questão 24
15. Solução Folha 37, Questão 25
16. Solução Folha 37, Questão 27
17. Solução Folha 37, Questão 28
18. Solução Folha 37, Questão 29
19. Solução Questão Tabelada 01
20. Solução Questão Tabelada 02
21. Solução Questão Tabelada 03
22. Solução Questão Tabelada 04
23. Solução Questão Tabelada 05
24. Solução Questão Tabelada 06
25. Solução Questão Tabelada 07
26. Solução Questão Tabelada 08

Resolução: Folha de Exercício 38.

[Voltar à Folha de Exercício 38]
1. Solução Folha 38, Questão 01
2. Solução Folha 38, Questão 02
3. Solução Folha 38, Questão 03
4. Solução Folha 38, Questão 05
5. Solução Folha 38, Questão 06
6. Solução Folha 38, Questão 07
7. Solução Folha 38, Questão 08
8. Solução Folha 38, Questão 09
9. Solução Folha 38, Questão 10
10. Solução Folha 38, Questão 11
11. Solução Folha 38, Questão 12
12. Solução Folha 38, Questão 13
13. Solução Folha 38, Questão 14
14. Solução Folha 38, Questão 15
15. Solução Folha 38, Questão 16
16. Solução Folha 38, Questão 17
17. Solução Folha 38, Questão 18
18. Solução Folha 38, Questão 19
 239

19. Solução Folha 38, Questão 20

20. Solução Folha 38, Questão 21
21. Solução Folha 38, Questão 22
22. Solução Folha 38, Questão 23
23. Solução Folha 38, Questão 24
24. Solução Folha 38, Questão 25
25. Solução Folha 38, Questão 27
26. Solução Folha 38, Questão 29