Tema1 - Aritmética Computacional em Python

14/11/22, 09:37 Aritmética computacional em Python
Aritmética computacional em Python

Prof. Francisco Roberto da Rocha Gomes
Descrição Aritmética Computacional, apresentação dos erros comuns na

linguagem Python e métodos clássicos de obtenção de raízes de
funções não lineares.
Propósito Entender a aritmética computacional como ferramenta essencial para

os profissionais que utilizaram programação para resolver problemas de
https://stecine.azureedge.net/repositorio/00212ti/02279/index.html# 1/90
modelagem matemática e os possíveis erros que podem ocorrer na

execução de algoritmos em uma linguagem específica.
Preparação Para compreender os conceitos abordados, é necessário prévio

conhecimento básico da linguagem Python.
Objetivos
Módulo 1 Módulo 2
Recursos do Python: Aritmética computacional:

programação e bibliotecas representação numérica
Reconhecer os conceitos básicos da Aplicar os recursos do Python na Aritmética
linguagem Python. Computacional.
Módulo 3 Módulo 4
Aritmética computacional: Zeros de funções não

erros lineares
Distinguir os principais tipos de erros Calcular zeros de funções não lineares
computacionais. utilizando Python.
Introdução
Este conteúdo não é um manual abrangente de Python. O único objetivo é
fornecer informações fiáveis para lhe dar um bom começo, se você não
estiver familiarizado com Python. Se você conhecer outra linguagem de
computador, e presumimos que sim, não é difícil que compreenda conforme
avança.
Os programas Python não são compilados em código de máquina, mas são

executados por um interpretador. A grande vantagem de uma linguagem
interpretada é que os programas podem ser testados e depurados
rapidamente, permitindo que o usuário se concentre mais nos princípios por
trás do programa e menos na programação em si. Não há necessidade de
compilar, vincular e executar após cada correção. Programas Python podem
ser desenvolvidos em muito menos tempo do que os programas Fortran ou

C equivalentes.
O interpretador Python pode ser facilmente encontrado para ser baixado no

site oficial. Normalmente, vem com um bom editor de código chamado Idle,
que permite a você executar programas diretamente do editor. Se você usa
Linux, é muito provável que o Python já esteja em paralisado em sua
máquina. O download inclui dois módulos de extensão que usamos em
nossos programas: o módulo numpy, que contém várias ferramentas para
operações de array, e o módulo gráfico matplotlib, utilizado na plotagem.
1 - Recursos do Python: programação e bibliotecas

Ao final deste módulo, você será capaz de reconhecer os conceitos básicos da linguagem Python.
O meu primeiro programa

Faremos um programa Python para avaliar uma fórmula simples. Nosso primeiro
exemplo diz respeito à programação de um modelo matemático que calcula a
altura de um objeto atirado na direção vertical, partindo de uma altura inicial

igual a zero. Da 2ª lei de Newton, e ao assumir uma resistência do ar desprezível,
obtemos um modelo matemático que determina a posição vertical y da bola no
tempo t:
2
y = v 0 t + 0.5gt
Onde:
V0 g
É a aceleração da gravidade no local,
É a velocidade inicial da bola.
que pode ser aproximado por 10m/s2.
Para obter a altura ao decorrer do tempo, precisamos saber da velocidade inicial,

que, para o nosso exemplo, será de 5m/s. Então, podemos escrever um arquivo
chamado de primeiroprograma.py, com o seguinte conteúdo:
Python
content_copy
1 # Programa para calcular a altura de um objeto em moviment

2 v0 = 5 # Velocidade inicial
3 g = 10 # Aceleração da gravidade
4 t = 0,5 # Tempo
5 y = v0 * t - 0,5 * g * t ** 2 # Posição vertical

6 print(y)
Agora, vamos entender as linhas do que seria o nosso primeiro programa em

Python.
code #
A primeira observação que vamos realizar é sobre as

palavras iniciadas com #. Isso significa que o interpretador
que executará o seu programa vai considerar o que vem
depois de # como comentários. Isso é muito importante
para documentar o seu programa, e, às vezes, nos lembrar
do que realmente estamos fazendo.
code v0 = 5 # Velocidade inicial
Essa linha é uma atribuição de variável, ou seja, toda a vez

que aparecer v0, o Python vai entender que é uma
representação de 5m/s. Uma maneira simples de entender o
https://stecine.azureedge.net/repositorio/00212ti/02279/index.html#
é t ib i ã i P th " i " 7/90
que é atribuição seria pensar que o Python gera uma "caixa"
no computador (memória) com o nome v0 escrito no topo.
O número 5 é, então, colocado nessa caixa. Sempre que o
Python, mais tarde, encontra o nome v0 no código, ele
encontra a caixa, de modo que o Python tira o número cinco
e substitui o nome v0 pelo número. Isso também acontece
com as linhas seguintes: g = 10 e t = 0,5.
code y = v0 * t - 0,5 * g * t ** 2 # Posição vertical
O Python já conhece três “caixas” com seus respectivos

valores v0, g e t, então, a linha seguinte contém a fórmula do
nosso modelo matemático: y = v0 * t - 0,5 * g * t ** 2.
Novamente, de acordo com suas regras, Python interpreta *
como multiplicação, - como menos e ** como
exponenciação. O Python executa a matemática e atribui o
resultado (neste caso, o número 1,25) à variável de nome y.
code print(y)
N últi li h d i t( ) é d 8/90
Na última linha, vem o comando print(y), que é um comando
de impressão na tela do valor de y, pois, caso não seja
colocado essa função print, o Python executaria a fórmula e
atribuiria na “caixa” y o valor de 1,25 e nada aparecia na tela.
Vamos falar um pouco sobre o termo atribuição de variáveis. Observe que

utilizamos o operador = para atribuir um valor numérico a uma representação,
como no exemplo v0, t e g. Nesse ponto, a linguagem de programação difere da
linguagem matemática. Para exemplificar essa diferença, usaremos a expressão
x= 4-x. Veja o que essa expressão significa em cada caso:
Matemática Programação
É uma simples equação, É necessário saber qual é o

onde a variável x = 2. valor x do lado direito,
subtraí-lo de 4 e atribuir
close esse resultado a x do lado
esquerdo. Geralmente, isso
acontece em processos
iterativos.
Nas próximas seções, serão apresentados alguns comandos e estruturas

básicas do Python, lembrando que as seções não são um aprofundamento da
linguagem Python, mas o básico para começarmos a trabalhar com a
modelagem matemática.
Strings
Agora, vamos tratar de recursos adicionais da linguagem para apoiar o

desenvolvimento dos códigos: os strings. O Python usa a tabela de caracteres,
que depende do seu sistema operacional, como, por exemplo, ASCII e UTF-8. Os
strings são colocados entre aspas simples (‘) ou duplas (“) e os caracteres que
são não imprimíveis podem ser expressos com a “barra-invertida” (\). Seguem
alguns exemplos:
\n \t \b
Cria uma nova linha. Cria uma tabulação. É uma backspace.
Vejamos exemplos de aplicação:
Python
content_copy Python
content_copy
1 >>>print('abc\nd') 1 >>>>print('abc\td')
2 abc 2 abc d
3 d
É possível obter o endereço dos caracteres dos strings usando a notação de

índices, string[índice], observando que, para o Python, o primeiro caractere tem
índice 0 e o último tem índice -1. Vejamos alguns exemplos:
Python
content_copy
1 >>> palavra = “abcd”

2 >>> palavra[0]
3 a
4 >>>palavra[-1]
5 d
Podemos também fatiar (slices) um string com a notação string[índiceI:índiceF].

Com esse comando, o Python nos retorna os caracteres, iniciando com o
caractere de índiceI (inclusive) e finalizando com o caractere que fica antes do
indiceF. Isso acontece, pois o indiceF é exclusivo. Por exemplo:
Python
content_copy
1
2 >>>
ab palavra[0:2]
Observe que o caractere correspondente ao índice 2 não apareceu.
Expressões Booleanas
São utilizados para realizar comparações relacionais e retornam verdadeiro
(True) e falso (False). Os operadores são:
< > <=
Menor que Maior que Men
Os exemplos a seguir mostram a resposta do Python ao comparar dados com as

saídas True e False.
Python
content_copy
1 >>> a = 2 # variável a recebe o v

2 >>> b = 1.99 # variável b recebe o
3 >>> c = ’2’ # variável c recebe o
4 >>> print(a > b) # perceba que o valor
5 True
6 >>> print(a == c) # note que c recebeu u
7 False
8 >>> print((a > b) and (a != c)) # os dois precisam ser
9 True
10 >>> print((a > b) or (a == b)) # apenas um precisa se
11 True
Operadores Aritméticos
No Python, podemos utilizar as operações aritméticas usadas na matemática

básica. Veja alguns exemplos dos operadores que o Python suporta:
+ - *
Adi ã
S bt ã M 13/90
Adição Subtração Mu
A seguir, apresentaremos alguns exemplos dessas operações e como o Python

responde.
Python
content_copy
1 >>> s = ’Olá’
2 >>> t = ’para você’
3 >>> a = [1, 2, 3]
4 >>> print(3*s) # Repetição
5 Olá Olá Olá
6 >>> print(3*a) # Repetição
7 [1, 2, 3, 1, 2, 3, 1, 2, 3]
8 >>> print(a + [4, 5]) # Adicionando elementos
9 [1, 2, 3, 4, 5]
10 >>> print(s + t)
11 Olá para você
Operadores Aritméticos
No Python, podemos utilizar as operações aritméticas usadas na matemática

básica. Veja alguns exemplos dos operadores que o Python suporta:
Tuplas e Listas
A tupla é uma sequência de objetos arbitrários separados por vírgulas e
incluídos entre parênteses. Se a tupla contém um único objeto, uma vírgula final
é necessária; por exemplo, x = (2,). Tuplas suportam as mesmas operações que
strings e são imutáveis. Veja a seguir um exemplo onde a tupla dados contém
outra tupla (31,10,73):
Python
content_copy
1 >>> dados = ('Gomes', 'Roberto', (31,10,73)) # E

2 >>> sobrenome, nome, data_de_nascimento = dados #
3 >>> print(nome)
4 Roberto
5 >>> Ano_de_nascimento = data_de_nascimento [3]
6 >>> print(Ano_de_nascimento)
7 73
8 >>> nome_competo = dados [1] + '' + dados [0]
9 >>> print(nome_completo)
10 Roberto Gomes
11 >>> print(rec [0: 2])
12 ('Gomes', 'Roberto')
Uma lista é semelhante a uma tupla, mas é mutável, de modo que seus
elementos e comprimento podem ser mudados. Uma lista é identificada
colocando-a entre colchetes. Seguem alguns exemplos da operações realizadas
em listas:
Python
content_copy
1 >>> a = [1.0, 2.0, 3.0] # Crie uma lista

2 >>> a.append (4.0) # Anexar 4.0 à lista
3 >>> print(a)
4 [1,0, 2,0, 3,0, 4,0]
5 >>> a.insert (0,0.0) # Insira 0.0 na posição 0
6 print(a)
7 [0,0, 1,0, 2,0, 3,0, 4,0]
8 >>> print(len (a)) # Determine o comprimento da
9 5
10 >>> a [2: 4] = [1.0, 1.0, 1.0] # Modifica os elementos
11 >>> print(a)
12 [0.0, 1.0, 1.0, 1.0, 1.0, 4.0]
Se a for um objeto mutável, como uma lista, a instrução de atribuição b = a não

resulta em um novo objeto b, mas, simplesmente, cria uma nova referência para
a. Portanto, quaisquer mudanças feitas para b serão refletidas em a. Veja, a
seguir, um exemplo:
Python
content_copy
1 >>> a = [1.0, 2.0, 3.0]

2 >>> b = a
3 >>> b[0] = 5.0
4 >>> print(a)
5 [5.0, 2.0, 3.0]
Para criar uma cópia independente de uma lista a, use a declaração c =a[:],
conforme mostrado no exemplo a seguir:
Python
content_copy
1 >>> c = a[:]
2 >>> c[0] = 1.0
3 >>> print(a)
4 [5.0, 2.0, 3.0]
video_library Meu primeiro programa em Python

No vídeo a seguir, apresentamos os principais comandos em Python na prática.
Importando Bibliotecas
Para dar uma visão aplicada ao nosso
estudo, começaremos com o

problema clássico de física do ensino
médio, que é o lançamento oblíquo, ou
seja, quando um objeto inicia seu
movimento formando um determinado
ângulo com a horizontal. Nesse tipo
de lançamento, o objeto executa dois
movimentos simultâneos, um na
Lançamento oblíquo.
vertical e outro na horizontal.
Comentário
Não precisaremos recapitular todo o assunto, já visto no ensino médio, para que
o objetivo deste conteúdo seja atingido.
Problema
A bala de um canhão, com massa (m) de 15kg, é lançada com velocidade inicial
(v0) de 300m/s. Determine o alcance horizontal máximo (A) do projétil para o
caso de o ângulo (θ) formado entre o canhão e a horizontal ser de 15°. Considere
a gravidade (g) igual a 10m/s.
Dos resultados do ensino médio, utilizaremos a fórmula de alcance máximo para

o lançamento oblíquo, dada por:
2
v sen 2θ
0
A =
g
Onde:
v0 θ g
É o ângulo com a É a gravidade.
É velocidade inicial.
horizontal
Então, colocamos as vaiáveis do problema e a fórmula A=v0**2*sin(2*theta)/g.

Ao executar o Python, aparece a seguinte mensagem de erro:
Python
content_copy
1 NameError: name 'sin' is not defined
O que isso significa? O Python não reconheceu a função

seno. Isso acontece porque muitas funcionalidades do
Python estão disponíveis em bibliotecas adicionais,

chamadas de módulos.
Embora o Python tenha muitas funções internas, como o print(), também possui
um conjunto de bibliotecas-padrão, que são programas em Python que podem
ser incluídos no seu programa. Usaremos o módulo math, pois ele disponibiliza
diversas funções matemáticas. Existem certas formas de “chamar” esses
módulos no seu programa, a seguir veremos algumas.
Python.
import “alguma-coisa”
A palavra-chave, nessa situação, é import, e, logo depois, coloca-se o módulo.

Por questão de organização, o ideal é colocar sempre no início do programa.
Então, antes de começar o programa para resolver o nosso problema, devemos
escrever:
Python
content_copy
1 >>>import math
Quando fazemos isso, temos acesso a todas as funções da biblioteca math, mas
devemos informar ao Python de qual biblioteca estamos chamando a função,
para isso utilizamos a sintaxe módulo.função(). Desse modo, utilizaremos o
math.sin() e o math.pi. Então, nosso programa pode ser escrito da seguinte
maneira:
Python
content_copy
1 >>>import math
2 >>>v0 =300
3 >>>g=10
4 >>>theta=15
5 >>>A= (v0**2/g)*math.sin(2*theta*math.pi/180)
6 >>>print(A)
7 4500
O resultado obtido é A = 4500.
from módulo import alguma-funções
Em nosso problema inicial, essa forma de “chamar” as funções do módulo sem

utilizar o prefixo ficaria:
Python
content_copy
1 >>>from math import sin, pi

2 >>>v0 =300
3 >>>g=10
4 >>>theta=15
5 >>>A= (v0**2/g)*sin(2*theta*pi/180)
6 >>>print(A)
Caso seja necessário utilizar todas as funções da biblioteca, basta usar o

comando from módulo import *. Veja o exemplo:
Python
content_copy
1 >>>from math import *
2 >>>v0 =300
3 >>>g=10
4 >>>theta=15
5 >>>A= (v0**2/g)*sin(2*theta*pi/180)
6 >>>print(A)
Importar um módulo com “apelidos”

O Python permite que importemos um módulo e atribuamos a ele um “apelido”,
para utilizar como prefixo ao chamar uma função. O comando é import módulo
as “apelido”. Desse modo, quando utilizar uma função da biblioteca, basta usar o
seguinte formato: apelido.função(). Por exemplo:
Python
content_copy
1 >>>import math as m
2 >>>v0 =300
3 >>>g=10
4 >>>theta=15
5 >>>A= (v0**2/g)*m.sin(2*theta*m.pi/180)
6 >>>print(A)
Observe que o apelido será m; assim, chamamos a função seno com m.sin(). De
maneira análoga, podemos atribuir “apelidos” para as funções from módulo
import função as apelido. Por exemplo:
Python
content_copy
1 >>>from math import cos as c, sin as s

2 >>>print(c(0) + s(0))
Funções
Até agora, vimos sobre biblioteca de funções, módulos, parâmetros, utilizando,
no entanto, o que o Python já tem pronto. É possível também criar a nossa
própria função e seus respectivos argumentos. Essa necessidade geralmente
ocorre quando algum procedimento se repete no programa. Por exemplo, vamos
supor que em um problema você tenha que calcular diversos alcances de um
lançamento oblíquo para diversos ângulos, respectivamente, 15º, 30º, 45º, 60ºe
75º, usando esse programa.
Python
content_copy
1 >>>import math
2 >>>v0 =300
3 >>>g=10
4 >>>theta=15
5 >>>
6 >>>print(A)
Uma solução para isso é criar uma função, e a estrutura para declarar uma
função em Python é dada da seguinte maneira:
def nome.Da.Minha.Função(Argumentos1, Argumentos2,….Argumentosn):
Declarações
return valor-de-retorno
A seguir, apresentaremos formas de executar procedimentos condicionados e

recursivos, que são importantes e comuns em funções.
Condicionais (if)
A construção de uma estrutura de condicionais no Python é dada por:
if condições:
bloco de instruções
elif condições:
else:
O exemplo a seguir é uma aplicação da estrutura if, onde o script decide se o

número é positivo, negativo ou zero:
Python
content_copy
1 >>>def sinal_numerico(a):
2 >>> if a < 0.0: # Se a menor que zero
3 >>> sinal = ’negativo’
4 >>> elif a > 0.0: # Se a maior que zero
5 >>> sinal = ’positivo’
6 >>> else: # Senão, ou seja, se a não é ma
7 >>> sinal = ’zero’
8 >>> return sinal
9 >>> a = 1.5
10 >>>print(’a é ’ + sinal_numerico(a))
11 a é positivo
O Comando for
Antes de falarmos sobre o comando for, vamos abordar a função range. A

função range retorna uma progressão aritmética de inteiros numa lista com a
seguinte estrutura: range (início,parada,incremento), onde:
Início Parada Incremento

É um parâmetro É o limite da progressão, É um parâmetro
opcional e o primeiro que termina no último opcional e indica o
valor a ser gerado, valor antes da parada. passo da progressão. O
quando não indicado, default, caso não seja
por default é o número informado, é um (1).
zero (0).
Vejamos uma aplicação:
Python
content_copy
1
2 >>> range(3) # parada indicada 3, como não foram indicados,
[0,1,2]
3 >>> range(2,5,2) # início 2, parada 5 e incremento 2
4 [2,4]
5 >>> range(5,2,-2) # o incremento é negativo
6 [5,3]
O comando for permite que nos informemos sobre os elementos de uma lista.
De modo geral, o comando é expresso da seguinte maneira:
for variável in lista : comandos
Uma grande utilidade da função range é construir a lista de iteração, como no

exemplo a seguir:
Python
content_copy
1 >>> for i in range(1,7): print(i)

2 1 2 3 4 5 6
Solução do Problema
Agora, vamos retornar ao nosso problema anterior, ou seja, calcular diversos

alcances de um lançamento oblíquo para diversos ângulos, por exemplo: 15º,
30º, 45º, 60ºe 75º. Uma maneira de resolver esse problema é:
Python
content_copy
1 >>> import math

2 >>> def Alcance(V0,theta,g):
3 >>> return (v0**2/g)*math.sin(2*theta*math.pi/180)
4 >>> v0=300
5 >>> theta = [15,30,45,60,75]
6 >>> n=len(theta)
7 >>> A =[]
8 >>> for i in range(len(theta)):
9 >>> A.append(Alcance(v0,theta[i],10))
10 >>> print(A)
11 4499.999999999999, 7794.228634059948, 9000.0, 7794.228634
Como fazer gráficos com o módulo

matplolib.pyplot
Vamos retornar ao nosso problema do início do conteúdo, ou seja: determinar a
posição vertical y da bola no tempo t. Para construir o gráfico dessa função,
utilizaremos o módulo matplotlib, usado, em geral, para realizar gráficos em 2D.
Python
content_copy
1 >>>import numpy as np
2 >>>import matplotlib.pyplot as plt
3 >>>v0 = 5 # Velocidade inicial
4 >>>g = 10 # Aceleração da gravidade
5 >>>t = np.linspace(0,1,1001)# Tempo
6 >>>y = v0 * t - 0.5 * g * t ** 2 # Posição vertical
7 >>>plt.plot(t,y) # plotar o grafico yxt
8 >>>plt.xlabel('t (s)') # eixo x com t(s)
9 >>>plt.ylabel('y (m)') # eixo y como y(m)
10 >>>plt.show() #mostrar a figura
Como saída, o Python apresenta o seguinte gráfico:
Gráfico: Resultado gerado no matplotlib.pyplot.

Elaborado por: Francisco Roberto da Rocha Gomes em código Python.
No programa apresentado, temos que destacar 2 pontos:
1. A função linspace retorna um vetor e a construção

genérica dele é linspace(a,b,n), onde gera um vetor
no intervalo [a,b] e com n pontos.
2. Quando utilizamos t como vetor, a função da altura

y(t) torna-se também um vetor.
Falta pouco para atingir seus objetivos.
Vamos praticar alguns conceitos?
Questão 1
Calcule o valor da expressão escrita em Python – (9**4 +2)*6 - 1.
A 39378
B 39377
C 39376
D 39375
E 39374
Parabéns! A alternativa B está correta.
O Python usa a mesma hierarquia de cálculo de expressões numéricas da

matemática, ou seja, primeiro exponenciação, depois multiplicação ou
divisão, e, por último, adição e subtração. Desse modo, calculamos primeiro
9**4 (nove a quarta potência), depois adicionamos 2, multiplicamos por 6 e,
por fim, subtraímos por 1 , resultando em 39377.
Questão 2
Seja o seguinte comando em Python:
a=[1,2,3,4,5]
a[-5]
Ao executá-lo, o que aparece?
A 1
B 5
C [3,4]
D [4, 5]
E [1,2,3,4,5]
Parabéns! A alternativa A está correta.
Em uma lista, os índices começam com 0. Nesse caso, a lista segue a ordem
até 4. Quando utilizamos índices negativos, ele usa a ordem inversa,
começando com -1 e indo até -5, ou seja, a[-5] = 1.
2 - Aritmética computacional: representação numérica

Ao final deste módulo, você será capaz de aplicar os recursos do Python na Aritmética Computacional.
Representação de números inteiros
Representação dos números inteiros positivos

A representação dos números inteiros positivos na base decimal (10) consiste

em um número de algarismo (0,1,2,3,4,5,6,7,8,9), o qual depende da respectiva
posição na representação.
Exemplo
O número 179 significa uma (1) centena (100) mais (+) sete (7) dezenas (10) e
nove (9) unidades, ou, de forma simplificada, por símbolos matemáticos: 179 =
1x102 + 7x10 + 9.
Agora, vamos generalizar essa notação matemática. Para isso, vamos adotar
como representação para qualquer digito numérico decimal a letra di, onde i é a
posição no número N com n+1 dígitos. Por exemplo, no número 179, o dígito
decimal 1 encontra-se na posição i=2; 7 na posição i=1; e 9 na posição i=0. Em
uma forma de notação matemática, temos:
n n−1 1 0
N = d n d n−1 . . . . d i , . . . d 1 d 0 = d n ×10 + d n−1 ×10 +. . . +d 1 ×10 + d 0 ×10 ,
Onde
0 ≤ di < 10, i = 0, 1, … , n
Outra notação comum para representar um número inteiro positivo na base 10 é
(dndn-1....di...d1d0 )10. Essa notação nos leva a outra, caso se deseje representar
o número com uma base diferente de 10, que seria N=(dndn-1....di...d1d0 )b , com
b sendo uma base diferente de 10; consequentemente, teremos 0≤ di < b.
n n−1 1 0
N = (d n d n−1 . . . . d i , . . . d 1 d 0 ) b = d n ×b + d n−1 ×b +. . . +d 1 ×b + d 0 ×b
As bases mais comuns na aritmética computacional são:
b=2 b=8 b=16

Binário Octodecimal Hexadecimal
Observe que, para b=2, por definição, os valores possíveis de d são 0 ou 1; de

maneira análoga, quando b=8, os valores que podem assumir são 0, 1, 2, 3, 4, 5, 6
e 7. Para os dígitos maiores que 9, adotamos as letras do nosso alfabeto, ou
seja, A,B,C ,…. Nesse caso, para a base hexadecimal (b=16), os dígitos possíveis
são 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E e F, onde A corresponde, na base decimal,
ao número 10, B corresponde ao 11, e assim, sucessivamente, até F, que
corresponde ao 15 . Vejamos alguns exemplos:
2 1 0
(101) 2 = 1 × 2 + 0 × 2 + 1 × 2
2 1 0
(175) 8 = 1 × 8 + 7 × 8 + 5 × 8
2 1 0
(A2D) 16 = A × 16 + 2 × 16 + D × 16
Mudança da base b para a base decimal 10 e da base

10 para a base b
A conversão de um número inteiro positivo, que se encontra em uma base
numérica b para a base decimal (10), é possível por meio da solução da seguinte
expressão:
n n−1 i 1 0
N = (d n d n−1 . . . . d i , . . . d 1 d 0 ) b = d n ×b + d n−1 ×b +. . . +d i ×b +. . . . +d 1 ×b + d 0 ×b
Então, veja o exemplo a seguir:
2 1 0
(101) 2 = 1 × 2 + 0 × 2 + 1 × 2 = 4 + 0 + 1 = 5
2 1 0
(175) 8 = 1 × 8 + 7 × 8 + 5 × 8 = 1 × 64 + 7 × 8 + 5 × 1 = 125
2 1 0 2
(A2D) 16 = A × 16 + 2 × 16 + D × 16 = 10 × 16 + 2 × 16 + 13 = (2605) 10
De modo geral:
n n−1 i 1 0
(d n d n−1 … d i , … d 1 d 0 ) = dn × b + d n−1 × b + … + di × b + … + d1 × b + d0 × b = (N ) 10 =
b
Onde N terá outros dígitos na base 10, como visto nos exemplos anteriores.
Para converter um número inteiro positivo N na base 10, para uma base b, é
necessário determinar os seus respectivos dígitos: di, de (dn dn-1....di,...d1 d0 )b.
Para entender o procedimento, devemos nos lembrar do algoritmo da divisão de
números inteiros positivos, onde, ao dividir um número D por um número d,
obtém-se um quociente q e um resto r; e quando r=0, dizemos que a divisão foi
exata e o resto só pode assumir os valores de 0,1,2...d-1. Formalizando por
símbolos matemáticos:
D=d×q+r, onde 0≤ r ≤d-1
Agora, vamos fazer a divisão de N, na base 10, pela base b que deseja se
transformar. Dessa forma, D=N e d=b, sendo necessário descobrir quem será o q
e o r. Lembrando o princípio da igualdade: se A=b, então, B=A. Podemos observar
que, na mudança da base b para a base 10, temos:
n n−1 i 1 0
dn × b + d n−1 × b + … + di × b + … + d1 × b + d0 × b = (N ) 10 = N
Logo, pelo princípio da igualdade:
n n−1 i 1 0
N = dn × b + d n−1 × b + … + di × b + … + d1 × b + d0 × b
n−1 n−2 i−1 0
q = dn × b + d n−1 × b + … + di × b + … + d1 × b
Se colocarmos b em evidência no n-1 primeiros termos da segunda parte da

expressão, obtém-se:
n−1 n−2 i−1 0

N = (d n × b + d n−1 × b + … + di × b + … + d1 × b ) × b + d0
Comparando com D=dxq +r, concluímos que:
n−1 n−2 i−1 0

q = d n xb + d n−1 xb + … + d j xb + … + d 1 xb e r = d0
Então, quando dividimos o número inteiro positivo N, na base 10, por um número
b na base desejada, obtemos o resto r igual ao último digito d0 da representação
de N-decimal na base b. Sabemos, pelo exemplo anterior, que 2605 = (A2D)16,
onde a letra D é o ultimo dígito na representação da base 16; de fato, quando
dividimos 2605 por 16, resulta, como quociente, q=162 e resto r=13, que, na
representação na base 16, é a letra D.
Portanto, o processo adotado será dividir N por b e obter q0 e r0 = d0; depois,

divide-se q0 por b, resultando em q1 e r1 = d1, e assim sucessivamente; os
respectivos restos serão os dígitos di, na base b, e o quociente da n-ésima e
última divisão será o dn.
Atenção
Define-se como bit (binary digit) o elemento de memória básico de um
computador que assume dois estados, que são representados pelos dígitos zero
(0) e um (1). O número de bits disponíveis para uma representação numérica de

inteiros positivos corresponde ao maior inteiro que o computador pode
representar, ou seja, com m bits é possível representar 2m números. Por
exemplo, para representar os oito dígitos decimais, seriam necessários três bits,
pois 23 = 8, entretanto, para representar 10 dígitos decimais são necessários
quatro bits, pois 24 = 16 configurações, o que é excedente, ou seja, no sistema
decimal há desperdício de bits.
Representação dos números inteiros negativos

A representação dos números inteiros
não positivos é realizada utilizando a
ideia do bit, ou seja, são
convencionadas para os sinais
positivo (+) ou negativo (-) as
representações de zero (0) ou um (1).
O único problema dessa
representação ocorre em operações
Binário
para obter os números +0 e -0, que,
embora para o computador sejam
números diferentes, sabemos que são
iguais.
Comentário
Existem diversas formas de resolver esse problema, mas não é o objetivo deste
conteúdo.
Representação dos números reais

O número real 95,32, representado na base decimal (10), pode ser escrito da
seguinte maneira:
1 0 −1 −2
9 × 10 + 5 × 10 + 3 × 10 + 2 × 10
Agora, vamos generalizar essa ideia: um número real r na base dez (10), com n+1
dígitos na parte inteira e m dígitos na parte fracionária, pode ser representado
como:
r = (d n d n−1 … d i , … d 1 d 0 , d −1 d −2 … d −m )
10
n n−1 1 0 −1
d n × 10 + d n−1 × 10 + … + d 1 × 10 + d 0 × 10 + d −1 × 10
−2 −m
+d −2 × 10 + … + d −m × 10
Utilizando o mesmo raciocínio, um número real r, representado em uma base b,

pode ser escrito da seguinte maneira:
r = (d n d n−1 … d i , … d 1 d 0 , d −1 d −2 … d −m )
b
n n−1 1 0 −1 −2 −m
dn × b + d n−1 × b + … + d1 × b + d0 × b + d −1 × b + d −2 × b + … + d −m × b
Mudança de base dez (10) para a base b

Para realizarmos a mudança de base dez para uma representação na base b de
um número real no formato r = i,f; onde:
i f
É a parte inteira. É a parte fracionária.
Devemos reparar ambas as partes, ou seja, fazer r = i + 0,f; tomando como

exemplo 95, temos 32 = 95 +0,32. Já vimos nas seções anteriores a
transformação da parte inteira; agora, vamos focar somente na parte fracionária
0,f. Então, vamos considerar que o nosso número real r só contém a parte
fracionária:
−1 −2 −m
r = (0, d −1 d −2 … d −m ) = d −1 × b + d −2 × b + … + d −m × b
b
O procedimento seria, primeiramente, lembrar que, para transformar um inteiro

na base (10) para uma base b, deveríamos dividir o número por b,
sucessivamente, e obter os restos. A ideia será a mesma, porém com uma
diferença, ao contrário de fazer divisões, faremos multiplicações, ou seja, o
primeiro passo será multiplicar o número real r pela base que se deseja
transformar, b. Em símbolos matemáticos, teríamos:
−1 −m+1
r × b = d −1 + d −2 × b + … + d −m × b
Obtém-se uma parte inteira, d-1, e a parte fracionária começa com d-2.
Multiplicando a parte fracionária restante por b, o resultado será d-2, e, assim,
sucessivamente. A seguir, veremos dois exemplos de conversão dos número
reais 0,625 e 0,2 para a base binária, o seja base dois (2):
Exemplo 1 Exemplo 2
0,625 x 2 = 1,250 = 1 + 0,250 0,2 x 2 =0,4 = 0 + 0,4
0,250 x 2 = 0,500 = 0 +0,500 0,4 x 2 = 0,8 = 0 + 0,8
0,500 x 2 = 1,000 = 1 + 0,000 0,8 x 2 = 1,6 = 1 + 0,6
Portanto, (0,625)10 = (0,101)2. 0,6 x 2 =1,2 = 1 + 0,2
Começa a repetir, portanto, (0,2)10 =

(0,001100110011...)2.
Esses dois exemplos ilustram que é possível, numa transformação de base dois
de um número real na base 10, obter um resultado cuja representação possui um
número finito de zeros e um ou um número infinito (dízima periódica) de zeros e
um.
Mudança da base b para a base 10

Seja r um número real na base b, (0, d-1d-2....d-m )b, para obter a sua
representação na base 10, basta aplicar a fórmula matemática já vista na seção
anterior:
−1 −2 −m
r = (0, d −1 d −2 … d −m ) = d −1 × b + d −2 × b + … + d −m × b
b
Por exemplo, converter o número (0,561)8 para a base 10, aplicando a fórmula:
−1 −2 −3
(0, 561) 8 = 5 × 8 + 5 × 8 + 5 × 8 = 0, 720703124
Notação Científica dos números reais
Nas ciências, é comum encontramos fenômenos ou grandezas cujos valores são

altos ou baixos, por exemplo, na Astronomia ou na Nanotecnologia. Para a
representação desses números, é necessária uma quantidade grande de dígitos.
A solução desse problema é usar a notação cientifica, cuja representação de um
número real é dada da seguinte forma:
e
r = ±M × b
Onde:
M b≥2 e
É um inteiro real não É um número inteiro É chamado de expoente.
negativo, chamado de positivo, chamado de
mantissa. base.
No entanto, essa notação possui uma ambiguidade. O número 0,1, por exemplo,
pode ser representado de formas equivalentes:
∘ −1 1 2 −2
0, 1 × 10 = 1 × 10 = 0, 01 × 10 = 0, 001 × 10 = 50 × 10 = …
Para resolver essa situação, foi imposta a seguinte condição à mantissa:
−1
M = 0 se r = 0 e b ≤ M < 1 se r ≠ 0
Essa condição define uma notação normalizada.
Representação em ponto flutuante

A notação científica abrange todos os números reais e, como sabemos, essa
quantidade é infinita, o que torna impossível de ser implementada em um
computador que possua uma quantidade finita de dígitos. A solução foi
modificar um pouco a normalização da notação científica da seguinte maneira:
Mantissa Expoente
Alterar para um número finito p de Criar um intervalo para o expoente, ou
dígitos. seja, o expoente e possui um valor
mínimo (emin) e um valor máximo
(emax).
A notação que usaremos é FP(b,p, emin, emax), para nos referirmos ao número no
sistema de ponto flutuante de base b, na qual a mantissa possui p dígitos (na
base b) e os expoentes estão contidos no intervalo fechado [emin, emax], ou seja,
r=0 ou r=±M×be, onde b-1 ≤ M ≤ 1 - b-p.
Tomamos como exemplo um número real representado em ponto flutuante

FP(10,4,-99,99). Pode ser escrito de forma genérica como r=±(0,d-1 d-2 d-3 d-
e
4)×10 , onde -99≤ e ≤ 99. Observe que essa representação não é capaz de
representar o número real 0,1x10100, pois o expoente é igual a 100 > 99, que é o
expoente máximo.
Atenção
Em uma modelagem matemática, isso é chamado de overflow. De maneira
semelhante, 0,1x10-100, e o motivo é o mesmo -100<-99, que é o valor mínimo.
Essa situação é definida como underflow.
video_library Mudanças de Bases em Python

No vídeo a seguir, abordaremos os principais comandos em Python que são
utilizados para mudanças de bases.
Questão 1
Qual é a representação do número 125 na base 6?
A (E2A)6
B (111)6
C (325)6
D (235)6
E (125)6
Parabéns! A alternativa C está correta.
Para encontrarmos o número desejado, faremos sucessivas divisões por 6.

Para isso, vamos executar os cálculos utilizando o Python. Usaremos o
operador % e a função int:
>>>N = 125; d0 = (N % 6);
>>>N = int(q/6); d1 = (N % 6);
>>>N = int(N/6); d2 = (N % 6);
>>> print(str(d2)+str(d1)+str(d0))
325
Questão 2
Obtenha a representação na base 4 do número (101,01)2.
A (11,1)4
B (111)4
C (10,1)4
D (1,11)4
E (10,1)4
Parabéns! A alternativa A está correta.
Para encontrar o número desejado, primeiramente, vamos converter o número

para a base 10, ou seja: 1⋅22+0⋅21+1⋅20+0⋅2-1+1⋅2-2=5,25, agora é converter o
número para a base 4. Em Python, basta utilizar o comando:
Primeiro com a parte inteira 5
>>>N = 5; d0 = (N % 4);
>>>N = int(N/4); d1 = (q % 4);
>>> print(str(d1)+str(d0))
11
Agora, a parte fracionária 0,25
f =0.25
d =int(4*f) ; f = 4*f - d; print('d=%d, x =%f' % (d,f))
d=1, x =0.000000
3 - Aritmética computacional: erros

Ao final deste módulo, você será capaz de distinguir os principais tipos de erros computacionais.
Erros na aritmética em pontos flutuantes

Neste módulo, vamos analisar o quanto a representação finita dos pontos
flutuantes influencia nos números reais. Por exemplo, se verificarmos no Phyton
2
(√ 5) = 5
se 22 = 4, a resposta será verdadeira, mas quando verificamos se ,a
resposta é falsa.
Erros de representação
A representação em pontos flutuantes só consegue ser realizada de maneira

exata para alguns números. Para outros números reais, poderá indicar algum
erro, logicamente supondo que os números não sejam overflow ou underflow.
Definiremos um número real, que esteja contido em um sistema ponto flutuante
FP(b,p, emin, emax ), de forma exata, de r=fl(r). Caso contrário, obteremos a
resposta r=fl(r) + erro.
Caso não seja possível representar o número real r no sistema de ponto flutuante
com exatidão, existem duas técnicas possíveis fl(r):
Arrendondamento por truncamento expand_more
Dada uma mantissa M de um número real r, com número de dígitos m> p,

onde p é o número de dígitos do sistema de ponto flutuante; define-se o
truncamento ao desprezar todos os dígitos a partir da posição p+1. Por
exemplo, seja o número real, na sua notação cientifica na base 10, igual a
r=0,341592654 x 10, se o representarmos num sistema de ponto
flutuante FP(10,4,-99,99), então, o resultado será fl(r) = 0,3415x10.
Arrendondamento por aproximação expand_more
Essa técnica é a mais comum e tem por objetivo reduzir o erro entre o
ponto flutuante fl(r) e o valor exato r, ou seja, o valor mais próximo.
Utilizando o exemplo anterior, aproximar fl(r) para 0,3416x10 tem um erro
menor que aproximar para o valor truncado.
O critério arrendondamento por aproximação, às vezes, pode apresentar

uma ambiguidade, por exemplo, quando o número real 0,15 for
arrendondado para um dígito, os números 0,1 e 0,2 estão igualmente
próximos. Para resolver esse problema, foram desenvolvidas várias
soluções e, para o sistema binário (b=2) e decimal (b=10), a mais comum
é arrendondar de forma que o último dígito seja par.
Atenção
Os arrendondamentos por truncamento e aproximação são realizados somente
na mantissa, ou seja, não é considerado erro no expoente.
Agora, podemos analisar os erros de representação de um número real e sem

perda de generalidade. Vamos considerar somente os números reais positivos
exatos na notação cientifica normalizada, ou seja, r = Mxbt, e o seu
correspondente no sistema de ponto flutuante fl(r) = mxbt, não necessariamente
normalizada. Define-se como erro absoluto E por:
t t t
E = f l(r) − r = m × b − M × b = (m − M ) × b
1
t−p
t−p |E| ⩽ b
|E| ⩽ b 2
É possível demonstrar que para o truncamento e para
aproximação. Define-se como erro relativo e:
f l(r) − r
e = ou f l(r) = (1 + e)r
r
1−p
e ⩽ u = b
De maneira análoga, pode-se demonstrar que para o truncamento
1
1−p
e ⩽ u = b
2
e para a aproximação, onde u é chamado de unidade de
arrendondamento.
Exemplo
Para determinar a unidade de arrendondamento u de FP(2,24,-99,99) para o
truncamento, temos:
1−p 1−24 −23 −6

b = 2 e p = 24, logo u = b = 2 = 2 ≃ 0, 16 × 10
Erros nas operações aritméticas

Nesta seção, vamos estudar como são os erros nas operações básicas da
matemática: soma, subtração, multiplicação e divisão, quando realizadas em um
sistema de ponto flutuante. Primeiramente, vamos descrever de
simplificadamente como são realizadas as quatro operações básicas no sistema
ponto flutuante. Para a soma e subtração de dois números no mesmo sistema
de ponto flutuante, x1=m1ba e x2=m2bc, onde a>c, sua soma e subtração podem
ser dadas por:
Soma Subtração
a c a c
x1 + x2 = m1 b + m2 b = (m 1 + m x 1 − x 2 = m 1 b − m2 b = (m 1 − m
Para a multiplicação e divisão, temos:
Multiplicação Divisão
a c a c
x 1 ×x 2 = m 1 b ×m 2 b = (m 1 ×m 2 ) x 1 ÷x 2 = m 1 b ÷m 2 b = (m 1 ÷m 2 )
Podemos observar que nas quatro operações, considerando os expoentes

inteiros, esses não são fontes de erros, somente nos casos de overflow e
underflow. Portanto, as fontes de erros encontram-se nas operações das
mantissas. Vamos considerar dois valores reais positivos, x1=m1ba e x2=m2bc , e
que x1 > x2 sejam os valores exatos:
Soma Subtração
y= x1 + x2 y= x1 - x2
Multiplicação Divisão
y= x1 * x2 y= x1 / x2
Em seguida, vamos definir as operações no sistema de pontos flutuantes. Por

exemplo, quando calculamos 1/7 + 1/60 no sistema decimal FP(10,4,-2,2),
temos:
∘ ∘
f l(1/7) = (0, 1429) ∗ 10 = (0, 1429) ∗ 10
∗ −1 ∗ ∘
f l(1/60) = (0, 1667) 10 = (0, 1667) 10
∗ ∘
y = f l(1/7) + f (1/60) = (0, 1596) ∗ 10
No entanto, o resultado exato é 67/20 = 0,1595238… e os erros absolutos e

relativos são E=(0,76)*10-4 e e=(0,48)*10-3. Agora, vamos estimar, de modo geral,
os erros absolutos e relativos para as quatro operações e, como já foi visto, fl(x)
= x(1 +e) e |e|< u (unidade de arredondamento). Vamos lá:
Adição expand_more
Como sabemos:
y
^ = f l (x 1 + x 2 ) = (1 + e 1 )x 1 + (1 + e 2 )x 2
O erro absoluto é dado por:
^ − y = e1 x1 + e2 x2
E = y
O erro relativo:
E x1 x2
e = = e1 ( ) + e2 ( )
y x1 + x2 x1 + x2
E a estimativa:
∗
|E| ≤ 2u y e |e| ≤ 2u
Subtração expand_more
Análoga à adição, a subtração é dada por:
^ = f l (x 1 − x 2 ) = (1 + e 1 )x 1 − (1 + e 2 )x 2
y
Logo, os erros absoluto e relativo são dados por:
^ − y = e1 x1 − e2 x2
E = y
E x1 x2
e = = e1 ( ) + e2 ( )
y x1 − x2 x1 − x2
E as respectivas estimativas:
∗
|E| ≤ 2u (|x 1 | + |x 2 |) e |e| ≤ 2u ((|x 1 | + |x 2 |)/ (|x 1 − x 2 |))
Multiplicação expand_more
Tendo y=x1*x2 como o produto exato de x1 e x2 , tem-se que:
y
^ = f l (x 1 × x 2 ) = (1 + e 1 ) (1 + e 2 )x 1 x 2
E = [(1 + e 1 ) (1 + e 2 ) − 1]x 1 x 2
e = (1 + e 1 ) (1 + e 2 ) − 1
Ou seja:
f l (x 1 × x 2 ) = (1 + e)x 1 x 2 com |e| ≤ 3u
Divisão expand_more
Tendo y=x1/x2 como o quociente exato de x1 e x2, tem-se que:
(1 + e 1 )x 1
y
^ = f l (x 1 ÷ x 2 ) =
(1 + e 2 )x 2
(1 + e 1 ) x1
E = [ − 1]
(1 + e 2 ) x2
(1 + e 1 )
e = − 1
(1 + e 2 )
Ou seja:
x1
f l (x 1 ÷ x 2 ) = (1 + e) com |e| ≤ 3u
x2
Exemplo
Para entendermos melhor, vamos calcular a subtração dos valores x1 =0,43787
*10-2 e x2 =0,43783 *102, para o sistema de ponto flutuante FP(10,4,-99,99), e

obter os erros absolutos e relativo. Para iniciar, o valor exato da subtração y = 0,4
* 10-6 e para o sistema de ponto flutuante, fl(x1 - x2) =0,1000 * 10-5. Dessa
maneira |E| = 0,60 * 10-6 e |e| = 1,5. Agora, observamos que, embora o erro
absoluto seja pequeno, o erro relativo foi alto. Esse problema é conhecido como
cancelamento, sendo comum nas operações que envolvem subtração. Existem
técnicas para diminuir o cancelamento e uma delas é acrescentar 1 ou 2 dígitos
na representação do número arredondado no sistema de ponto flutuante
utilizado.
Alguns cálculos em Python

Vamos supor que queiramos realizar as seguintes somas no Python:
1 y = 0.1 + 0.1 + 0.1 sabemos que o resultado é 0,3;
3000
Σ xk xk
k=1
y= para constante e igual a 0,5, o valor
exato é 15000;
3000
Σ xk xk
k=1
y= para constante e igual a 0,1, o valor
exato é 3000.
Agora, veja a solução em Python:
Python
content_copy
1 # Soma 1
2 >>>soma = 0.1 + 0.1 + 0.1
3 >>>print('soma = '+str(val))
4 soma =0.30000000000000004
5
6 # Soma 2
7 >>>n = 30000
8 >>>lista1 = [0.5] * n
9 >>> print('sum(lista1) = '',sum(lista1)')
10 sum(lista1) = 15000.0
11
12 # Soma 3
13 >>>n = 30000
video_library Cálculos de erros em Python

No vídeo a seguir, abordaremos os conceitos de erros computacionais e como
podem ser observados em Python.

Questão 1
Sabendo que o valor exato de um número n = 2345.713 e que, por um

processo computacional, foi obtido um valor aproximado de 2346.000.
Calcule os erros absoluto e relativo.
A 0.710 e 0.00250000
B 0.716 e 0.00031340
C 0.731 e 0.00030396
D 0.713 e 0.00030369
E 0.713 e 0.00030396
Parabéns! A alternativa E está correta.
Realizando os cálculos no Python:
>>>n_exato = 2345.713
>>>n_aprox = 2345.000
>>>E_abs = abs(n_exato - n_aprox)
>>>print(E_abs)
>>>E_relativo = E_abs/n_exato
>>>print(E_relativo)
0.7130000000001928
0.0003039587536924563
Questão 2
√2
Para calcular o valor de , é possível utilizar o método iterativo
1 2
x n+1 = (x n + )
2 xn
, para n=0,1,2… Determine o erro relativo entre o
x0 = 1 x1
chute inicial e .
A 0,05882
B 0,00173
C 0,02222
D 0,33333
E 0,00001
Parabéns! A alternativa D está correta.
1 2 x1 − x0
x0 = 1 x1 = (x 0 + ) = 1.500, = 0, 33333
2 x0 x1
4 - Zeros de funções não lineares

Ao final deste módulo, você será capaz de calcular zeros de funções não lineares utilizando Python.
Zeros de equações lineares

Neste módulo, vamos estudar alguns métodos mais conhecidos para obter as
raízes de funções não lineares. O problema consiste em, dada uma função não
linear f(x), encontrar um z, tal que f(z) seja igual a zero. Esses métodos são os
primeiros algoritmos que vamos estudar, usando técnicas iterativas. Uma
técnica iterativa, geralmente, é realizada da seguinte forma:
looks_one Primeiro passo
x0
É dado um valor inicial ( ), que, às vezes, chamamos de
chute inicial.
looks_two Segundo passo
x1
É calculado o próximo valor , geralmente, com a seguinte
x1 = x0 + p
formulação matemática: , onde p é um passo.
O passo pode ser constante ou depender de x, ou seja, p(x).
looks_3 Terceiro passo
x i+1 p(x i )
São calculados os próximos até o ficar tão
pequeno quanto desejamos, normalmente adotado em uma
tolerância, tol. Então, a iteração pode ser dada pela seguinte
anotação:
x i+1 = x i + p (x i ), |p (x 1 )| ≥ tol
√2
Agora, vamos determinar a raiz quadrada de dois, usando o método iterativo,
x0 = L
com chute inicial . Seja x o valor que queremos encontrar, então,
2 2
x = √2 ⇒ x = 2 2x
; somamos em ambos os lados .
2 2 2
2x + x = 2x + 2
2 2 2
2x + 2x = x + 2 ÷ (2x)
2
x − 2
x = x −
2x
Neste caso, o passo é:
2
x − 2
p (x) =
2x
Pelo modo iterativo:
2
x − 2
i
x i+1 = x i −
2x i
x0 = 1
Agora, com , temos:
2 2
x − 2 1 − 2
0
x1 = x0 − = 1 − = 1, 5
2x 0 2 ⋅ 1
2 2
x − 2 1, 5 − 2
1
x2 = x1 − = 1 − = 1, 4167
2x 1 2 ⋅ 1, 5
Método da bisseção
O método da bisseção consiste na ideia de obter uma raiz, z, que esteja
exatamente no ponto médio de um intervalo. Esse intervalo é obtido pelo
processo iterativo do método, onde parte da hipótese que existe, pelo menos,
uma raiz contida nesse intervalo inicial. Além disso, esse intervalo inicial tem
como condição que os valores da função não linear, no intervalo entre os
extremos, tenham os sinais opostos.
Em notação matemática: seja o intervalo I= [a,b], se f(a).f(b)< 0. Nesse intervalo I,

existe pelo menos uma raiz, z. Essa afirmação é do Teorema de Bonzano e pode
ser visualizada graficamente a seguir.
Gráfico: Teorema de Bonzano.

Elaborado por: Francisco Roberto da Rocha Gomes.
Seja o intervalo inicial I0 =[a0,b0] = [a,b], de tal modo f(a) . f(b)< 0, ou seja, f(a) e
f(b) possuem sinais contrários. Adotaremos a notação de Ii = [ai, bi], os intervalos
na primeira iteração i=1, na segunda iteração i=2, e, assim, sucessivamente. Para
x i+1
Ii, teremos o ponto médio, , isto é:
ai + bi
x 1+1 =
2
f (z i+1 ) = 0 z i+1
Se , então, é o zero da função e interrompe o algoritmo; se
f (z i+1 ). f (a i ) f (z i+1 ). F (b i )
não, deverá verificar o sinal de e . Caso
f (z i+1 ). f (a i ) < 0 f (z i+1 ). F (b i ) > 0 bi z 1+1

e ,o o substitui por ,
I i+1 = [a 1 , z i+1 ] a 1+1 = a i

determinando o intervalo , ou seja, fizemos a e
b i+1 = z i+1 f (z i+1 ). f (a i ) > 0 f (z i+1 ). f (b i ) < 0,

. Caso contrário de e
a i+1 = z i+1 b i+1 = b i

fazemos e .
Assim, podemos garantir que o zero sempre estará em um dos intervalos.

Segundo as iterações, e dividindo pela metade de intervalos, vamos confirmando
o zero da função f(x) em um intervalo tão pequeno quanto desejar.
Python
content_copy
1 >>>import math
2 >>>from numpy import sign
3 >>>def bisection(f,x1,x2,switch=1,tol=1.0e-9):
4 >>> f1 = f(x1)
5 >>> if f1 == 0.0: return x1
6 >>> f2 = f(x2)
7 >>> if f2 == 0.0: return x2
8 >>> if sign(f1) == sign(f2):
9 >>> print('Raiz não se encontra no intervalo
10 >>> n = int(math.ceil(math.log(abs(x2 - x1)/t
11 >>> for i in range(n):
12 >>> x3 = 0.5*(x1 + x2); f3 = f(x3)
13 >>> if (switch == 1) and (abs(f3) > ab
14 >>> and (abs(f3) > ab
Método do secante
O método do secante consiste, basicamente, em obter uma reta que contém os
(x i−1 , f (x i−1 )) (x i , f (x i−1 )) (x i+1 , f (x i+1 ))

pontos e , e obter o ponto que
f (x)
é a interseção com a função . A diferença desse método com o de
bissecação é que não é necessário verificar a condição do Teorema de Bonzano:
f (x i−1 ) × f (x i )
é ou não menor que zero. O método está ilustrado no gráfico
a seguir.
Gráfico: Método do secante.

x i+1
A expressão que determina o valor de é dada por:
f (x i )x i−1 − f (x i−1 )x i
x i+1 =
f (x i ) − f (x i−1 )
A expressão anterior pode apresentar um erro de cancelamento. Para evitar isso,

pode-se reescrever a expressão como:
X i+1 = x i + p i onde p i = f (x i )/ [f (x i ) − f (i − 1))/ (x i − x i−1 )]
f (x i )
x i+1 = x i + p i , onde pi =
[f (x i ) − f (x i−1 )/ (x i − x i−1 )]
Agora, vamos ao algoritmo:
Python
content_copy
1 >>>import sys
2 >>>def secant(f, x0, x1, eps):
3 >>> f_x0 = f(x0)
4 >>> f_x1 = f(x1)
5 >>> numero_de_iteracoes = 0
6 >>> while abs(f_x1) > eps and numero_de_iteracoe
7 >>> try:
8 >>> denominador = (f_x1 - f_x0)/(x1 -
9 >>> x = x1 - f_x1/denominador
10 >>> except ZeroDivisionError:
11 >>> print('Erro! - denominador zero p
12 >>> sys.exit(1)# Sair do programa cas
13 >>> x0 = x1
14 >>> x1 = x
Veja agora um exemplo de uso do método secant expresso no código anterior:

Python
content_copy
1 >>> def f(x):

2 >>> return x**2 - 9
3 >>> x0 = 1000; x1 = x0 - 1
4 >>> solucao, no_iteracao = secant(f, x0, x1, eps=1.0e-
5 >>> if no_iteracao > 0:# Solucao achada
6 >>> print('Numero de fuções calculadas {:d}'.forma
7 >>> print('A solução é: {:f}'.format(solucao))
8 >>> else:
9 >>> print('Solução não achada!')
10 Número de funções calculadas: 19
11 A solução é: 3.000000
Método de Newton – Raphson
O método de Newton-Raphson partiu da mesma ideia do método da secante,

com uma diferenciação: agora, em vez de iniciar com dois pontos, vamos iniciar
(x i , f (x i )) f (x)
somente com um ponto , determinar a reta tangente a função
nesse ponto e obter a interseção dessa reta, como o eixo-x, determinando xi+1,
como ilustra o gráfico a seguir.
Gráfico: Método de Newton-Raphson.

g (x) = mx − n
De modo geral, a equação da reta é dada por , onde:
m n
É o coeficiente angular. É o termo independente.
Para determinar esses valores, precisamos de um pouco de álgebra e de

conhecimento de cálculo. Do cálculo, tiramos que m é igual à derivada de f (x)
em xi, f’(xi), pois a reta é tangente à função; e da álgebra, concluímos que a
equação dessa reta tangente é:
′
g(x) = f (x i ) − f (x i ) (x − x i )
x i+1
Logo, ao calcular , que é a interseção de g (x) com eixo-x, ou seja,
g (x i+1 ) = 0
, chegamos a:
f (x i )
x i+1 = x i −
′
f (x i )
f (x i )
x i+1 = x i −
′
f (x i )
Ou seja, o passo p_ipi do método de Newton . Porém, nem
sempre é possível obter o valor da derivada algebricamente; na maioria das
vezes, a derivada é obtida numericamente conforme vemos a seguir, com um
valor de h muito pequeno, determinado pelo modelo matemático:
f (x i + h) − f (x i )
′
f (x i ) ≃
h
Atenção
x0
O método de Newton é eficiente quando o chute inicial, , é próximo da raiz
que se deseja determinar. Algumas vezes, é interessante obter uma raiz
aproximada com outro método (por exemplo, da Bisseção) e aplicar o método de

newton para obter uma raiz mais precisa.
Agora, veja o código Python.
Python
content_copy
1 >>>def f(x): return x**4 - 6.4*x**3 + 6.45*x**2 + 20.538*x

2 >>>def df(x): return 4.0*x**3 - 19.2*x**2 + 12.9*x + 20.5
3 >>>def newtonRaphson(x,tol=1.0e-9):
4 >>> for i in range(30):
5 >>> dx = -f(x)/df(x)
6 >>> x = x + dx
7 >>> if abs(dx) < tol: return x,i
8 >>> print('Muitas iterações\n')
9 >>>raiz,numIter = newtonRaphson(2.0)
10 >>>print( 'Raiz =',raiz)
11 >>>print('Numero de iterações =' ,numIter)
video_library Cálculos de zeros de funções não lineares

em Python
No vídeo a seguir, abordaremos os conceitos de cálculo de zeros de funções em
Python.
Questão 1
M
−n
C = [1 − (1 + r) ]
r
Considere a seguinte equação: , em que C é o
capital emprestado, M é a mensalidade, r é a taxa de juro por cada período
(expressa como uma fracção) e n é o número de anos. Uma pessoa pode
pagar uma mensalidade de R$1.250,00. Se pretender contrair um empréstimo
de R$10.000,00 a 10 anos, qual é a taxa que poderá suportar?
OBS.: O valor da taxa deve estar entre 0.01 e 0.05. Use um método iterativo
que não recorra à derivada.
A 0,0151
B 0,0456
C 0,0428
D 0,0500
E 0,0482
Parabéns! A alternativa C está correta.
Substituindo os dados da questão e fazendo a r=x , temos a seguinte função,

na qual desejamos encontrar a raiz.
1250 −10
f (x) = [1 − (1 + x) ] − 10000 = 0
x
Usando o programa em Python:
>>>import math
>>>from numpy import sign
>>>def biss(f,x1,x2,switch=1,tol=1.0e-9):
>>> f1 = f(x1)
>>> if f1 == 0.0: return x1
>>> f2 = f(x2)
>>> if f2 == 0.0: return x2
>>> if sign(f1) == sign(f2):
>>> print('Raiz não existe nesse intervalo')
>>> n = int(math.ceil(math.log(abs(x2 - x1)/tol)/math.log(2.0)))
>>> for i in range(n):
>>> x3 = 0.5*(x1 + x2); f3 = f(x3)
>>> if (switch == 1) and (abs(f3) > abs(f1)) / and (abs(f3) > abs(f2)):
and (abs(f3) > abs(f2)):

>>> return None
>>> if f3 == 0.0: return x3
>>> if sign(f2)!= sign(f3): x1 = x3; f1 = f3
>>> else: x2 = x3; f2 = f3
>>> return (x1 + x2)/2.0
>>>def f(x): return (1250/x)*(1 - (1+x)**(-10)) -10000
>>>x = biss(f, 0.01, 0.05, tol = 1.0e-4)
>>>print('x =', '{:6.4f}'.format(x))
x = 0.0428
Questão 2
A relação entre a distância y (quilômetros) percorrida pela lava de um vulcão

em erupção e o tempo t (horas) é dada por:
t
y = 7 (2 − 0.9 )
y = 10
Existe uma aldeia no sopé da montanha a uma distância de .O
gabinete de proteção civil advertiu os moradores da aldeia de que a lava
chegaria às suas casas em menos de 6 horas. Calcule, utilizando o método
de Newton, o instante de tempo em que a lava do vulcão atinge a aldeia.

10 −3
Considere como tolerância .
x
da
x
= a ln(a)
dx
Obs: .
A 5,3141
B 5,4113
C 5,3411
D 5,1341
E 5,3114
Parabéns! A alternativa E está correta.
Substituindo os dados da questão e fazendo a t=x, temos a seguinte função,

na qual desejamos encontrar a raiz:
t
f (x) = 7 (2 − 0.9 ) − 10 = 0
E sua derivada:
x
df (x) = −7 × 0.9 × ln(0.9)
Então, usando o método de Newton:
>>>import numpy as np
>>>def f(x): return 7*(2 - 0.9**x) -10
>>>def df(x): return -7*(0.9**x)*np.log(0.9)
>>>def newtonRaphson(x,tol=1.0e-3):
>>> for i in range(30):
>>> dx = -f(x)/df(x)
>>> x = x + dx
>>> if abs(dx) < tol: return x,i
>>>print('Muitas iterações\n')
>>>x,numIter = newtonRaphson(2.0)
>>>print('x =', '{:6.4f}'.format(x))
>>>print('Numero de iterações =' ,numIter)
x = 5.3114
Numero de iterações = 3
Considerações finais
Chegamos ao final deste conteúdo, no qual apresentamos conceitos
fundamentais para a modelagem matemática. Nesta, a representação numérica
em base binária possui limitações computacionais que podem causar erros.
Esses erros podem ser mensurados e, dependendo do conhecimento dos valores
exatos, podemos calculá-los.
Para exemplificar essas representações, utilizamos a linguagem Python,

iniciamos conceitos de variáveis, strings, listas e aprendemos a definir funções.
O Python, embora seja uma linguagem interpretada, é muito poderosa e
apresenta muitas funcionalidades nos módulos, como, por exemplo, math,
numpy e matplotlib, sendo o último usado para construir gráficos com estilo
semelhante ao MatLab.
Finalmente, começamos com uns dos primeiros modelos de matemáticos

iterativos para determinar os zeros de funções não lineares. Descrevemos os
algoritmos dos métodos da Bisseção, Newton e Secantes. Os métodos da
Bisseção e Secantes não utilizam derivadas, à diferença do método de Newton,
em que é necessário calcular a primeira derivada da função, da qual se deseja
calcular o zero e possui a limitação do chute inicial, que deve se encontrar
próximo da raiz. O método da bisseção é necessário para determinar o intervalo

no domínio da função que contenha o zero. Para isso, é utilizado o teorema de
Bolzano.
headset Podcast
Ouça, no podcast, uma explicação a respeito dos recursos do Python na
aritmética computacional e dos principais tipos de erros computacionais.
Referências
BURDEN, R. L.; FAIRES, J. D. Análise Numérica. São Paulo: Thomson, 2003.
DIEGUEZ, J. P. P. Métodos de Cálculo Numérico. Rio de Janeiro: Fundação

Ricardo Franco, 2005.
IEEE. Standard for Floating-Point Arithmetic. In: EEE Std 754-2019 (Revision of
IEEE 754-2008), vol., no., pp.1-84, 22 July 2019, doi:
10.1109/IEEESTD.2019.8766229.
RUGGIERO, M. A. G.; LOPES, V. L. R. Cálculo Numérico: aspectos teóricos e

computacionais. São Paulo: Makron Books, 1996.
Explore +
Você pode acessar e realizar o download de bibliotecas de Python disponíveis
nos sites Phyton, Jupyter e Colaboratory.
Pesquise o site Matplotlib para explorar diversas maneiras de fazer gráficos e

figuras em Python.

Tema1 - Aritmética Computacional em Python

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Tema1 - Aritmética Computacional em Python

Enviado por

Direitos autorais:

Formatos disponíveis

14/11/22, 09:37 Aritmética computacional em Python

Aritmética computacional em Python

Descrição Aritmética Computacional, apresentação dos erros comuns na

Propósito Entender a aritmética computacional como ferramenta essencial para

modelagem matemática e os possíveis erros que podem ocorrer na

Preparação Para compreender os conceitos abordados, é necessário prévio

Recursos do Python: Aritmética computacional:

Aritmética computacional: Zeros de funções não

Os programas Python não são compilados em código de máquina, mas são

ser desenvolvidos em muito menos tempo do que os programas Fortran ou

O interpretador Python pode ser facilmente encontrado para ser baixado no

1 - Recursos do Python: programação e bibliotecas

O meu primeiro programa

altura de um objeto atirado na direção vertical, partindo de uma altura inicial

Para obter a altura ao decorrer do tempo, precisamos saber da velocidade inicial,

1 # Programa para calcular a altura de um objeto em moviment

5 y = v0 * t - 0,5 * g * t ** 2 # Posição vertical

Agora, vamos entender as linhas do que seria o nosso primeiro programa em

A primeira observação que vamos realizar é sobre as

code v0 = 5 # Velocidade inicial

Essa linha é uma atribuição de variável, ou seja, toda a vez

code y = v0 * t - 0,5 * g * t ** 2 # Posição vertical

O Python já conhece três “caixas” com seus respectivos

Vamos falar um pouco sobre o termo atribuição de variáveis. Observe que

É uma simples equação, É necessário saber qual é o

Nas próximas seções, serão apresentados alguns comandos e estruturas

Agora, vamos tratar de recursos adicionais da linguagem para apoiar o

Vejamos exemplos de aplicação:

É possível obter o endereço dos caracteres dos strings usando a notação de

1 >>> palavra = “abcd”

Podemos também fatiar (slices) um string com a notação string[índiceI:índiceF].

Observe que o caractere correspondente ao índice 2 não apareceu.

< > <=

Menor que Maior que Men

Os exemplos a seguir mostram a resposta do Python ao comparar dados com as

1 >>> a = 2 # variável a recebe o v

No Python, podemos utilizar as operações aritméticas usadas na matemática

A seguir, apresentaremos alguns exemplos dessas operações e como o Python

No Python, podemos utilizar as operações aritméticas usadas na matemática

1 >>> dados = ('Gomes', 'Roberto', (31,10,73)) # E

1 >>> a = [1.0, 2.0, 3.0] # Crie uma lista

12 [0.0, 1.0, 1.0, 1.0, 1.0, 4.0]

Se a for um objeto mutável, como uma lista, a instrução de atribuição b = a não

1 >>> a = [1.0, 2.0, 3.0]

video_library Meu primeiro programa em Python

estudo, começaremos com o

Dos resultados do ensino médio, utilizaremos a fórmula de alcance máximo para

Então, colocamos as vaiáveis do problema e a fórmula A=v0**2*sin(2*theta)/g.

1 NameError: name 'sin' is not defined

O que isso significa? O Python não reconheceu a função

Python estão disponíveis em bibliotecas adicionais,

A palavra-chave, nessa situação, é import, e, logo depois, coloca-se o módulo.

O resultado obtido é A = 4500.

from módulo import alguma-funções

Em nosso problema inicial, essa forma de “chamar” as funções do módulo sem

1 >>>from math import sin, pi

Caso seja necessário utilizar todas as funções da biblioteca, basta usar o

1 >>>from math import *

Importar um módulo com “apelidos”

1 >>>from math import cos as c, sin as s

def nome.Da.Minha.Função(Argumentos1, Argumentos2,….Argumentosn):

A seguir, apresentaremos formas de executar procedimentos condicionados e

A construção de uma estrutura de condicionais no Python é dada por:

Então, colocamos as vaiáveis do problema e a fórmula A=v0**2sin(2theta)/g.