UFRB- Universidade Federal do Recôncavo da Bahia

CETENS- Centro de Ciência e Tecnologia em Energia e Sustentabilidade

Maira Pinto Oliveira

Métodos de Cálculo Numérico

Relatório Técnico

Feira de Santana
2021
 Maira Pinto Oliveira

Métodos de Cálculo Numérico

Relatório Técnico apresentado ao curso de

Bacharelado Interdisciplinar em Energia e Sus-
tentabilidade, como parte dos requisitos ne-
cessários à segunda avaliação do componente
curricular de Cálculo Numérico ministrado pelo
docente Anderson Dourado Sisnando.

Feira de Santana
2021

2
 Sumário

Introdução .....................................................................................................................

Metodologia ...................................................................................................................

Resultados e Discussão ...............................................................................................

Método de interpolação de Newton...........................................................................

Regra dos trapézios..................................................................................................
Regra de Simpson ..................................................................................................
Imagens das Compilações dos Métodos................................................................

Conclusão....................................................................................................................

Referências Bibliográficas .........................................................................................

3
1. Introdução

O presente relatório traz a resolução de quatro questões utilizando os métodos

de Cálculo Numérico estudados na segunda unidade, método de intepolação de new-
ton, regra dos trapézios e a regra de simpso. Onde através de programas computacio-
nais e da linguagem de programação, ao construir os algoritmos você consegue calcu-
lar a tabela de diferenças dividas e encontrar os polinômios das funçoes f(x) através
dos pontos informados. Os algoritmos desse trabalho foram escritos em linguagem C
no programa DEVC++, seguidos os seus respectivos comentários de construção.

4
2. Metodologia

Para resolução do trabalho proposto, foi utilizado o programa DEVC++,

visto pelo discente na disciplina de Programação de Computadores I, adqui-
rindo afinidade para construção dos algoritmos em linguagem C++.
Utilizou -se os conhecimentos vistos em sala de aula sobre o método de
interpolação de Newton, regra do trapézio e a regra de Simpson transcre-
vendo a lógica dos métodos para obtenção dos valores de diferenças dividi-
das em forma de tabela, os polinômios de interpolação, assim como a esti-
mativa do erro no calculo em uma das questões.
No método de interpolação de Newton definimos:
1º Pontos da função F(x), x e y.
2º Tabela de diferenças divididas.
3º Polinômio de interpolação segundo o método de Newton, P(x).
4º Estimativa para um F(x).
Para a tabela de diferenças divididas definimos:
f[x0] = f(x0)
f[x0 , x1 ] = ( f[x1] - f[x0] ) / (x1 - x0 )
f[x0, x1, x2] = (f[x1, x2] - f[x0, x1]) / (x2 - x0)
f[x1, x2, x3,....,xn] = ( f[x1,....., xn] - f[x0,....., xn-1] ) / (xn - x0)
notação: Δnf
obs: O calculo de uma Δnf depende de todas as Δjf anteriores, j<k!
Exemplo de uma tabela de diferenças divididas:
X F(x) Δf Δ2f Δn-1f Δnf
x0 F(x0) f[x0, x1] f[x0,x1,x2] : f[x1,..,xn]
x1 F(x1) f[x1, x2] f[x1,x2,x3] : :
x2 F(x2) f[x2, x3] : : :
: : : : : :
: : : : : :
xn F(xn) : : : :

A tabela é nesse formato de triângulo, pois os valores abaixo da diag-

onal secundária não são calculados.,
A partir da definição de diferença dividida de ordem 1 de f(x), temos
que: f[x0 , x ] = ( f[x] - f[x0] ) / (x - x0 )
Isolando o f(x) da igualdade: f(x) = f(x0) + (x - x0)f[x0 , x ]
logo, para ordem n temos:
5
 f[xn-1,..,x1,x0, x]
f(x) = f(x0)+(x-x0)f[x0,x]+(x-x0)(x-x1)f[x0,x1,x]+...+(x-x0)(x-x1)...(x-xn-1)f[x0,x1,..,xn-1, x]
A expanção de f(x) serve para a definição do polinômio P(x), que é de-
nominado polinômio de interpolação de Newton:
f(x) = f(x0)+(x-x0)f[x0,x]+(x-x0)(x-x1)f[x0,x1,x]+...+(x-x0)(x-x1)...(x-xn-1)f[x0,x1,.,xn-1, xn]
Ainda é possivel calcular o erro de interpolação, que é o erro cometido
na substituição de f(x) por P(x), onde P(x) é o polinômio de interpolação, ide-
pendente do método utilizado para encontrar, utilizando a seguinte formula:
E = | f(x) - P(x) | = | fn+1 (c) / (n+1)! |
o c é algum ponto do interior de um intervalo.
Entrando nos calculos de integrais, temos quê, se uma função é conti-
nua em [a,b], então o teorema fundamental do cálculo afirma quê:

isso significa que o cálculo de uma integral é imediato quando se conhece

uma primitiva F(x) para a função f(x). No geral, o cálculo númerico aproxima-
do consiste no cálculo de um somatório em vez da primitiva de alguma fun-
ção.
Algumas técnicas de cálculo aproximado de integrais consistem na
aproximação da função f(x) por um polinômio de interpolação P(x), usando en-
tão:

como sendo uma aproximação de:

Se P(x) for do primeiro grau, então temos a regra do trapézio.

6
 Na regra do trapézio composta definimos:
1º Intervalo [a,b].
2º Valor de n, quantidade de partes iguais que o intervalo é dividido.
3º altura h = (b - a) / n.
4º valores de xj = a + jh (com j = 0,1,2...,n).
5º valores de yj = f(xj).
6º In = (h/2) * (y0 + 2y1 + y2 +...+yn) ou In = h/2 * Σ ti yi (sendo ti=1,2,2,...,1)

A regra de Simpson para o cálculo de:

consiste em aproximar essa integral por:

Na regra de Simpson composta definimos:

1º Intervalo [a,b].
2º Valor de n, quantidade de partes iguais que o intervalo é dividido.
3º altura h = (b - a) / n.
4º valores de xj = a + jh (com j = 0,1,2...,n).
5º valores de yj = f(xj).
6º In = (h/3) * (y0 + 4y1 + 2y2 +...+yn) ou In = h/3*Σciyi (sendo ci=1,4,2,...,4,1)
7º Erro, E = | ( In - In/2 ) / 15 |, se n for um inteiro múltiplo de quatro.

Os métodos serão explorados nas questões:

7
(Quetão 1)

(Quetão 2)

8
(Quetão 3)

(Quetão 4)

9
3.Resultados e Discussão
Bibliotecas utilizadas para compilação dos programas.
#include <stdio.h>
#include <locale.h>
#include <math.h>
#include <stdlib.h>
#define VERMELHO "\x1b[31m"
#define RESET "\x1b[0m"
main(){
system ("color 7D");
setlocale(LC_ALL, "portuguese");

Menu para que o usuario possa escolher a questão que deseja responder ou testar va-
lores, de de dois do-while. Um para que não seja escolhido nenhum valor diferente das
opções e o outro que pega todo o código, para no final de cada questão, caso deseje,
o usuario possa voltar para este menu.

do{
do{
printf(" *TRABALHO PRÁTICO_ UNIDADE 2* \n");
printf(" ____________________________");
printf(" \n | 1- QUESTÃO 1 |"
"\n | 2- QUESTÃO 2 |"
"\n | 3- QUESTÃO 3 |"
"\n | 4- QUESTÃO 4 |"
"\n | 5- SAIR |"
"\n |____________________________|\n");
scanf("%d", &op);
}while(op<1 || op>5);
switch(op){

Questão 1 Variáveis usadas durante a re-

do{ solução da questão

int Tvetor, m=0, n=0, l=1, d, p;

float del;

printf("(Questão 1) Construir tabela de diferenças dividas da função f(x) dos valores

que seram informados.\n\n");
o Tvetor corresponde a
quantidade de pontos para
que seja definido o tamanho
printf("Quantos valores de X e Y deseja informar?") ; dos vetores de X e Y que
scanf("%d", &Tvetor); iram guardar esses valores

Foi necessário utilizar alo-

cação dinâmica para evitar
float * X = new float[Tvetor]; os erros consequentes de
float * Y = new float[Tvetor]; memória cheia

10
for(int i=0; i<Tvetor; i++){
Pedindi e guardando os valo-
res de X

printf("Informe o valor de X[%d]:", i);

scanf("%f", &X[i]);
}
system ("cls");
for(int i=0; i<Tvetor; i++){

printf("Informe o valor de Y[%d]:", i); Pedindi e guardando os va-

lores de Y

scanf("%f", &Y[i]);
}
system ("cls");

printf("X |");
for(int j=0; j<Tvetor; j++){
printf(" %.4f |" , X[j]);
}
printf("\nY |");
for(int j=0; j<Tvetor; j++){
printf(" %.4f |" , Y[j]);
}
Foi necessário fazer um ve-
tor para guardar os valores
n = Tvetor - 1; de delta, pois para calcular
//vetor para colocar os valores de delta_f n Δnf é necessário os valo-
float * Vdel = new float[n]; res de Δn-1f

printf("\n");
printf("%df |",l);
for(int j=0; j<n; j++ ){ Calculo do primeiro deltaf
for(int k=0; k<n; k++){

del = (Y[j+1] - Y[j])/ (X[j+l]-X[j]);

Vdel[j] = del;
}

printf("%.4f | ",del);

printf("\n");

11
d=n;
do{ calculo dos proximos deltas a partir
d-=1; dos resultados do primeiro até o Δnf
l+=1; por isso tem o decremento na vi-
printf("%df |",l); avel d que inicialmente recebe o
valor de n.
for(int i=0; i<d;i++){
del = (Vdel[i+1] - Vdel[i])/(X[i+l]-X[i]);
Vdel[i] = del;
printf("%.4f |", del);
}
printf("\n");
}while(d>0 && l<n);

delete X;
delete Y;
printf("\n\nDeseja tentar outros valores para esta questão? (s=sim/n=não)");
scanf(" %c",&res);
system ("cls"); Caso odigite ‘s’ todo
printf("\n\n"); o processo ira se repe-
tir
} while (res=='s');

12
 Questão 2
Para fazer o método de interpolação de Newton é necessário primeiro
fazer o calculo das diferenças divididas, e como a questão 1 pedia a ta-
bela de difereçãs divididas foi aproveitado do mesmo código na parte ini-
cial com alguns incrementos para apresentar uma estimativa pra f(x),
sendo x um valor qualquer.

do{
int Tvetor, n=0, d=0, p=1, l=1, s=1;
float del=0.0, aprox=0.0, fator, x;

printf("(Questão 2) Usando o método de interpolação de Newton,

obtenha uma estimativa para f(0), sendo f(x) uma função cujos valores
seram informados.\n\n");

printf("Quantos pontos deseja informar?");

scanf("%d", &Tvetor);

float * X = new float[Tvetor];

float * Y = new float[Tvetor];

for(int i=0; i<Tvetor; i++){

printf("Informe o valor de X[%d]:", i);
scanf("%f", &X[i]);
}

for(int j=0; j<Tvetor; j++){

printf("Informe o valor de Y[%d]:", j);
scanf("%f", &Y[j]); pedindo o valor de x
que o usuario deseja es-
} timar

printf("Qual o ponto x a ser estimado:");

scanf("%f", &x);

system ("cls");
13
 printf("\nX |");
for(int i=0; i<Tvetor; i++){
printf("%.4f |" , X[i]);
}

printf("\nY |");
for(int i=0; i<Tvetor; i++){
printf("%.4f |" , Y[i]);
}

n = Tvetor - 1;
float * Vdel = new float[n];
vetor criado para guardar os valores Δnf dos X0,,
float * pol = new float[n]; para ser mais facil fazer o calculo do polinô-
mio e imprimir uma estimativa para o f(x)
desejado
printf("\n");
printf("%df |",l);
//for para saber quantos deltaF iremos fazer
for(int j=0; j<n; j++ ){
for(int k=0; k<n; k++){
del = (Y[j+l] - Y[j])/ (X[j+l]-X[j]);
Vdel[j] = del;

}
printf("%.4f | ",del);
if(j==0){ guardando o valor do
Δnf de X0
pol[j]=del;
}

printf("\n");
d=n;
do{
d-=1;
14
 l+=1;
printf("%df |",l);
for(int i=0; i<d;i++){
del = (Vdel[i+1] - Vdel[i])/(X[i+l]-X[i]);
Vdel[i] = del;
printf("%.4f |", del);
verificando a posição do
if(i==0){ vetor esta vazia para guar-
dar os proximos valores de
Δnf correspondentes ao
X0
if(pol[i]!=0){

pol[i+p]=del;
p++;
}
}
}
printf("\n");
}while(d>0 && l<n);
do{
for(int j=0; j<n; j++){
fator = pol[j];
Cálculo da estimativa de F(x)
usando os valores de X, f(x0) e os
for(int i=0; i<s; i++){ valores de Δnf dos X0.
fator*=(x - X[i]);
}
s+=1;
aprox+=fator;
}
aprox+=Y[0];
}while(s<=n);

printf("\n\no valor aproximado de"VERMELHO" f(%.4f) = %f" RESET,x, aprox);

Impressão do f(x), para um x

diferentes dos que estão na
tabela.

15
 delete X;
delete Y;
delete Vdel;
delete pol;

printf("\n\nDeseja tentar outros valores para esta questão? (s=sim/n=não)");

scanf(" %c",&res);
system ("cls");
printf("\n\n");

} while (res=='s');
Questão 3
do{
float a, b, h, n, X, Y, I=0, t=1, mult=0, soma=0;
printf("(Questão 3) Calcular a integral definida em [1,2] de (1 + x^3)^(1/2)
usando a regra dos trapézios com n=6.\n\n");
printf("Informe o valor de a:");
scanf("%f", &a); pedindo valores de a, b e n
e calculando o valor de h a
printf("Informe o valor de b:"); partir dos mesmos
scanf("%f", &b);
printf("Informe quanto vale n:");
scanf("%f", &n);

h = (b-a)/n;
printf("i| xi | yi | ti | Yt\n");
for(int i=0; i<=n; i++){

X = a + (i*(h));
calculo dos valores X e Y

Y= pow ((1 + pow(X,3)), 0.5);

if(i > 0 && i<=(n-1) ){

verificando para saber em
t = 2; ques posições t vai valer
2 ou 1

}
16
 else{
t=1;
}
for(int j=0; j<=n;j++){
multiplicação de Y*t, e a
variavel soma guarda o
somatório de todos os Y*t
mult = Y * t;
}
soma+=mult;

printf("%d| %.5f | %.5f | %.5f | %.5f\n", i, X, Y, t, mult);

}

calculo e resultado da integral

I = ((h/2)* soma); usando a regra dos trapézios

printf("\nI = %.5f\n", I);

printf("\n\nDeseja tentar outros valores para esta questão?
(s=sim/n=não)");
scanf(" %c",&res);
system ("cls");
printf("\n\n");

} while (res=='s');

Questão 4
do{
int n1=0, n2=0, k=1, C=0;;
float a, b, X=0, Y=0, h1=0, h2=0, soma1=0, soma2=0, mult1=0,
mult2=0, I1=0, I2=0, E;

printf("(Questão 4) Calcular uma aproximação para a integral defi-

nida em [1,2] da função f(x) = ((4x^5 - 1)/ (x^5 + x + 1)^2) usando a regra
de Simpson composta com n=8 e n=16. Obter uma estimativa para o erro
da aproximação\n\n");
17
 printf("Valor de n%d:",k);
scanf("%d", &n1);
system("cls");
printf("Valor de n%d:",k++); pegando valores
de n e [a,b]
scanf("%d", &n2);
system("cls");
printf("Informe o intervalo da integral definida:[a,b]");
scanf("%f %f", &a ,&b);
system("cls");

h1 = (b-a)/n1; calculo do n1 e
n2 informados
h2 = (b-a)/n2;
printf("TABELA PARA n = %d\n\n", n1);

printf("\n____________________________________________________
_____");
printf("\ni| X |Y |C | C*Y |");

printf("\n____________________________________________________
____|");
for(int i=0; i<=n1; i++){
Calculo dos valo-
X = a + (i*h1); res de X e Y

Y = (4* pow(X,5) - 1)/(pow ((pow(X,5)+X+1),2));

if(i > 0 && i<=(n1-1) ){
if(i%2==0){
C = 2;
}else{
testes para saber em ques
C=4; posições o C vai receber
} os valores de 1, 4 ou 2.

}
else{
C=1;
}

18
 for(int j=0; j<=n1;j++){

mult1 = Y * C; multiplicação e
somatório dos
} Y*C

soma1+=mult1;

printf("\n%d| %.4f | %.5f | %d | %.5f ", i, X, Y, C, mult1);

printf("\n____________________________________________________
__________|");
}

printf("\n\nTABELA PARA n = %d\n\n", n2);

printf("\n____________________________________________________
_____");
printf("\ni| X |Y |C | C*Y |");

printf("\n____________________________________________________
____|");
for(int i=0; i<=n2; i++){
X = a + (i*h2);
Y = (4* pow(X,5) - 1)/(pow ((pow(X,5)+X+1),2));
if(i > 0 && i<=(n2-1) ){
if(i%2==0){
C = 2; Agora para os
valores de n2
}else{
C=4;
}
}
else{
C=1;
}

19
 for(int j=0; j<=n2;j++){

mult2 = Y * C;
}
soma2+=mult2;

printf("\n%d| %.4f | %.5f | %d | %.5f", i, X, Y, C,

mult2);

printf("\n____________________________________________________
_________|");
}

I1 = (h1/3)*soma1;
I2 = (h2/3)*soma2;
if(I2 > I1){
E = (I2 - I1)/15;
}else{
E = (I1 - I2)/15;
calculo e resultado da inte-
} gral e do erro usando a re-
gra de Simpson
if(E<0){
E*=(-1);
}

printf("\nI%d ="VERMELHO" %.10f"RESET"\n",n1, I1);

printf("\nI%d ="VERMELHO" %.10f"RESET"\n",n2, I2);
printf("\nE ="VERMELHO" %.10f"RESET"\n", E);
printf("\n\nDeseja tentar outros valores para esta questão? (s=sim/n=não)");
scanf(" %c",&res);
system ("cls");
printf("\n\n");
} while (res=='s');

20
 Se o usuario não quiser testar mais nenhum método é so escolher essa opção no me-
nu e o codigo vai encerrar.
case 5:{
exit(0);
break;
}

Mensagem para saber ser o usuario quer voltar para o menu e testar outro método,
aparece no fim de todos os métodos caso o usuario não queira testar outro intervalo.

system ("color E5");

printf("\n\nDeseja utilizar outro método? (s=sim/n=não)");
scanf(" %c",&resu);
system ("cls");
printf("\n\n");
}while(resu=='s');
}
}
Os resultados esperados para cada questão podem ser encontrados no final de cada
algoritmo, como se pode observar nas imagens de cada questão a seguir.

Imagens das compilações das questões

Questão 1:

21
Questão 2:

22
Questão 3:

Questão 4:

23
24
4. Conclusões

As questões foram resolvidas e desenvolvidas de modo satisfatório de acordo aos mé-

todos estudados, atingindo o objetivo do trabalho em programar, imprimir, organizar
em tabelas, encontrar uma estimativa para um f(x) de um x escolhido pelo usuário e
uma estimativa para o erro de aproximação na regra de Simpson.

25