Trabalho de Calculo Numrico II

Professor: Valdemir Garcia Ferreira

Aluno: Rubens Abranches Filho
N 5713752

Previsor-Corretor
O mtodo previsor-corretor utilizado para resoluo de Mtodos Lineares de Passo
Mltiplos implcitos. Utilizando um mtodo explicito resolveremos o mtodo implcito e para o
mtodo explicito chamaremos Previsor.
Como mtodo explicito adotamos o Mtodo de Euler
P: yn+1 = yn + hfn
No cdigo do programa ficou
y[0][n+1] = Y[n] + h*f(c1, c2, exp1, exp2, X[n], y[0][n]);
Onde f a funo
float f(float c1, float c2, float exp1, float exp2, float x, float y)
{
return c1*pow(x, exp1) + c2*pow(y,exp2);
}

que o cdigo para o caso geral f(x) = y'(x) = c1xexp1 + c2yexp2

Para o mtodo implcito, que chamamos de corretor, adotamos a Regra do Trapzio
C: yn+1 = yn + 1/2h(fn + fn+1)
O cdigo ficou
y[S+1][n+1] = Y[n] + 0.5*h*(f(c1, c2, exp1, exp2, X[n], Y[n]) + f(c1, c2, exp1, exp2, X[n+1], y[S][n+1]));

O Algoritmo se deu da seguinte forma

Dado o PVI da forma geral
y'(x) = c1xexp1 + c2yexp2
y(0) = C, 0 x b
pedido como entrada ao usurio os valores de c1, c2, exp1, exp2, C e b respectivamente.
O programa divide o intervalo por h = 0,1 ((b-0)/h) e os valores so inseridos em xn da forma
for (j = 0; j <= i; j++)
X[j] = j*0.1;
sendo i = (float)(b)/0.1;
Em seguida feita a chamada para a funo PrevisorCorretor
for (n = 0; n <= i; n++)
PrevisorCorretor (n, c1, c2, exp1, exp2, X, Y, y);
Dessa forma obtemos todos os valores da funo para cada xn
A funo PrevisorCorretor funciona da seguinte forma
Para n = 0
Obtemos o valor de y(0)1 a partir do clculo de y(0)n+1 = yn + hfn (O Previsor)
Em seguida calculado y(s)1 (O Corretor), a partir do clculo de
y(s+1)n+1 = yn + 1/2h[f(xn, yn) + f(xn+1, y(s)n+1)]
sendo s inicialmente igual a 0
Se | y(1)n+1 - y(0)n+1 | < E = 10-3 ento y1 = yn+1 = y(1)1 = y(1)n+1
mas seno fazemos (s+1) e calculamos novamente at obtermos o resultado desejado.

Isso feito para obtermos um erro menor que 10-3.

Aps concluir isso fazemos (n+1) e repetimos o procedimento do comeo.
Estudo de Caso
Para estudo de caso adotamos o PVI
y'(x) = x2 y2
y(0) = 1, 0 x 2
Y0(x0 = 0.000000) = 1.000000
s=1
Y1(x1 = 0.100000) = 0.909095
s=1
Y2(x2 = 0.200000) = 0.835336
s=1
Y3(x3 = 0.300000) = 0.776740
s=1
Y4(x4 = 0.400000) = 0.732232
s=1
Y5(x5 = 0.500000) = 0.701302
s=1
Y6(x6 = 0.600000) = 0.683802
s=1
Y7(x7 = 0.700000) = 0.679788
s=1
Y8(x8 = 0.800000) = 0.689389
s=1
Y9(x9 = 0.900000) = 0.712696
s=1
Y10(x10 = 1.000000) = 0.749664
s=1
Y11(x11 = 1.100000) = 0.800023
s=1
Y12(x12 = 1.200000) = 0.863221
s=1
Y13(x13 = 1.300000) = 0.938388
s=1
Y14(x14 = 1.400000) = 1.024347
s=1
Y15(x15 = 1.500000) = 1.119654
s=1
Y16(x16 = 1.600000) = 1.222680
s=1
Y17(x17 = 1.700000) = 1.331720
s=1
Y18(x18 = 1.800000) = 1.445101
s=0
Y19(x19 = 1.900000) = 1.561408
s=0
Y20(x20 = 2.000000) = 1.679081
s=0
E estes foram os resultados obtidos

Foi possvel observar que a medida que aumentamos o intervalo existe uma maior necessidade
de resolver o erro, portanto a medida que que aumentamos o valor de xn o mtodo se torna menos
eficiente.
| y(1)90 - y(0)90 | = 13.960827
| y(2)90 - y(1)90 | = 5.357533
| y(3)90 - y(2)90 | = 3.118959
| y(4)90 - y(3)90 | = 2.164844
| y(5)90 - y(4)90 | = 1.399325
| y(6)90 - y(5)90 | = 0.958065
| y(7)90 - y(6)90 | = 0.634813
| y(8)90 - y(7)90 | = 0.430887
| y(9)90 - y(8)90 | = 0.288076
| y(10)90 - y(9)90 | = 0.194654
| y(11)90 - y(10)90 | = 0.130620
| y(12)90 - y(11)90 | = 0.088069
| y(13)90 - y(12)90 | = 0.059192
| y(14)90 - y(13)90 | = 0.039869
| y(15)90 - y(14)90 | = 0.026815
| y(16)90 - y(15)90 | = 0.018053
| y(17)90 - y(16)90 | = 0.012146
| y(18)90 - y(17)90 | = 0.008175
| y(19)90 - y(18)90 | = 0.005501
| y(20)90 - y(19)90 | = 0.003702
| y(21)90 - y(20)90 | = 0.002491
| y(22)90 - y(21)90 | = 0.001677
| y(23)90 - y(22)90 | = 0.001128
| y(24)90 - y(23)90 | = 0.000759
Y90(x90 = 9.000000) = 8.944349

Cdigo do programa em C
#include <stdio.h>
#include <math.h>
#define NUM 1000
float f(float c1, float c2, float exp1, float exp2, float x, float y)
{
return c1*pow(x, exp1) + c2*pow(y,exp2);
}
void PrevisorCorretor (int n, float c1, float c2, float exp1, float exp2, float
X[], float Y[], float y[][NUM])
{
float h = 0.1;
float E = pow(10, -3);
//PREVISOR
y[0][n+1] = Y[n] + h*f(c1, c2, exp1, exp2, X[n], y[0][n]);
//CORRETOR
int S = 0;
do
{
y[S+1][n+1] = Y[n] + 0.5*h*(f(c1, c2, exp1, exp2, X[n], Y[n]) + f(c1, c2,
exp1, exp2, X[n+1], y[S][n+1]));
//CORRIGINDO ERRO
if (fabs(y[S+1][n+1] - y[S][n+1]) <= E)
Y[n+1] = y[S+1][n+1];
else
S++;

}
while (fabs(y[S+1][n+1] - y[S][n+1]) > E);
printf("Y%d(x%d = %f) = %f \n", n, n, X[n], Y[n]);
printf("s = %d\n", S);
}
int main ()
{
int n, j;
float c1, c2, exp1, exp2, X[NUM], Y[NUM], y[NUM][NUM], i, b, a;
X[0] = 0;
printf("entre com os argumentos Y'(x) = C1*X^exp1 + C2*Y^exp2 \n");
//ENTRADA
printf("C1 = ");
scanf("%f", &c1);
printf("C2 = ");
scanf("%f", &c2);
printf("exp1 = ");
scanf("%f", &exp1);
printf("exp2 = ");
scanf("%f", &exp2);
//PVI
printf("entre com o valor de Y(0) = ");

scanf("%f", &Y[0]);
printf("entre com o intervalo 0 <= X <= b \n");
printf("entre com o valor de b = ");
scanf("%f", &b);
y[0][0] = Y[0];
i = (float)(b)/0.1;
for (j = 0; j <= i; j++)
X[j] = j*0.1;
for (n = 0; n <= i; n++)
PrevisorCorretor (n, c1, c2, exp1, exp2, X, Y, y);
return 0;
}