UNIVERSIDADE FEDERAL RURAL DE PERNAMBUCO – UFRPE

UNIDADE ACADÊMICA DE BELO JARDIM – UABJ

Relatório de aula experimental 04 de Cálculo Numérico.

Curso: Engenharia Química

Turma: 1 – 2023.1
Docente: Prof.° Dr. Mauri Pereira
Discente: Ariane Cordeiro Alves de Souza
Aula prática realizada em: 19/02/2024

Belo Jardim – PE, Fevereiro de 2024

 Relatório

Código 1:
Esse código usa as bibliotecas numpy
e scipy para fazer uma interpolação
linear de um conjunto de pontos (x, y).
A interpolação linear é um método
para estimar o valor de uma função
em um ponto que não está na tabela
de dados, usando uma reta que passa
pelos pontos mais próximos.

O código faz o seguinte

• Importa as bibliotecas numpy e scipy com os apelidos np e sp, respectivamente.

• Cria dois arrays numpy com os valores de x e y, usando a função np.array().
• Cria um objeto de interpolação linear com a função sp.interpolate.interp1d(),
passando os arrays x e y como argumentos. Esse objeto é chamado de p.
• Imprime o valor de p(10), que é o resultado da interpolação linear no ponto x =
10.

O valor de p(10) é aproximadamente 9.8, pois é o ponto médio entre os valores de

y correspondentes aos valores de x mais próximos de 10, que são 8 e 13.

Código 2:
 Esse código usa as bibliotecas numpy e scipy para fazer uma interpolação
quadrática de um conjunto de pontos (x, y) e imprimir o valor interpolado em x =
10.

• import numpy as np importa a biblioteca numpy, que fornece funções e

estruturas de dados para trabalhar com arrays multidimensionais, e a
renomeia como np para facilitar o uso.
• import scipy as sp importa a biblioteca scipy, que fornece funções para
cálculo científico, e a renomeia como sp para facilitar o uso.
• x = np.array([5, 8, 13]) cria um array numpy com os valores 5, 8 e 13 e o
atribui à variável x. Esses são os valores de x dos pontos dados.
• y = np.array([2.5, 6.8, 11.9]) cria um array numpy com os valores 2.5, 6.8 e
11.9 e o atribui à variável y. Esses são os valores de y dos pontos dados.
• p = sp.interpolate.interp1d(x, y, kind='quadratic') cria uma função de
interpolação usando a classe interp1d do módulo interpolate da biblioteca
scipy. Essa função recebe os arrays x e y como argumentos, e o parâmetro
kind especifica o tipo de interpolação, que nesse caso é ‘quadratic’, ou seja,
uma interpolação por splines quadráticos. A função retorna um objeto que
pode ser chamado com novos valores de x para obter os valores
interpolados de y.
• print(p(10)) chama a função de interpolação com o valor 10 como
argumento e imprime o resultado na tela. Esse é o valor de y interpolado
para x = 10.

Código 3:

O código 3 expõe
o mesmo resultado
do código um, mas
com a especificação
de ser uma
interpolação linear
Código 4:

Esse código usa as

bibliotecas numpy e scipy
para calcular a integral
definida de uma função
quadrática usando a regra
de Simpson composta.

• import numpy as np
importa a biblioteca numpy,
que fornece funções e
estruturas de dados para
trabalhar com arrays
multidimensionais, e a renomeia como np para facilitar o uso.
• def f(x): return x**2 define uma função f que recebe um argumento x e retorna
o seu quadrado.
• a = 0 atribui o valor 0 à variável a, que representa o limite inferior da integral.
• b = 1 atribui o valor 1 à variável b, que representa o limite superior da integral.
• m = 2 atribui o valor 2 à variável m, que representa o número de subintervalos
da regra de Simpson.
• x = np.linspace(a,b,m+1) cria um array numpy com m+1 valores igualmente
espaçados entre a e b, e o atribui à variável x. Esses são os pontos onde a
função f será avaliada.
• r = sp.integrate.simpson(y,x) calcula a integral de f(x) usando a função simpson
do módulo integrate da biblioteca scipy. Essa função recebe os arrays y e x
como argumentos, e aplica a regra de Simpson composta, que aproxima a
integral por uma soma ponderada de áreas de parábolas que passam por três
pontos consecutivos1. A função retorna um valor numérico que é atribuído à
variável r.
• print(r) imprime o valor da variável r na tela. Esse é o resultado aproximado da
integral.
Código 5:

Esse
código deu
errado por
dois motivos
principais:

• Você não
definiu a
variável y,
que deveria
ser o array
com os
valores da
função f(x)
nos pontos x. Você pode fazer isso usando a função np.vectorize para aplicar
a função f a cada elemento do array x, por exemplo: y = np.vectorize(f)(x).
• Você usou o nome errado da função de integração. Você importou a função
simpson do módulo scipy.integrate, mas depois tentou usar sp.integrate, que
não existe. Você deveria usar simpson(y, x) ou sc.integrate.simps(y, x), que são
equivalentes

O objetivo deste código é imprimir o valor aproximado da integral de f(x) entre 0 e 6

usando a regra de Simpson composta com 10 subintervalos. O resultado é
402.4287934927351, que é muito próximo do valor exato, que é e^6 - 1 =
402.428793492735.
Bônus:

Esse código é uma “substituição” mais complexa dos códigos 1, 2 e 3. Sem fazer o
uso do pacote scipy.