Grupo : Carlos José Carniato; Clauton Cipriano de Paula; Daniel Dutra da Costa Lima;

Daniel Moreira Antunes; Ramsés Tarciso de Lacerda Marques.

9. Diferenças Finitas.
Métodos para problemas de valor de
fronteira

9.1. Introdução
Alguns problemas comuns em engenharia consistem por exemplo da deflexão de

uma viga que está sujeita a uma carga uniforme. Esta situação pode ser modelada

matematicamente por uma equação diferencial que aproxima a situação física.

Os métodos de solução de problemas de valor de fronteira envolvendo diferenças

finitas, consistem em restituir cada uma das derivadas na equação diferencial na equação

diferencial por uma aproximacão, "diferença-quociente",apropriada.

9.2. Motivação
Essa diferença-quociente é geralmente escolhida segundo a manutenção de uma

ordem de erro de truncamento.

O problema de valor de fronteira de segunda ordem,linear:

y''=p(x)y'+q(x)y+r(x)

a ≤ x ≤ b, y ( a ) = α , y (b) = β , requer que aproximações (diferença-quociente) sejam usadas

196
para aproximar ambos y' e y''.Para realizar isto,selecionamos um inteiro N>0 e dividimos

o intervalo [a,b] em N+1 subintervalos, cujos pontos finais são os pontos xi =a+ih,para

(b − a )
i=0,1,2,...,N+1, onde h = . Escolhendo a constante h desta maneira, teremos um
( N + 1)

sistema de equações lineares que poderá ser colocado como uma matriz NxN, facilitando a

aplicação do algorítmo para solução do sistema de equações de equações lineares.

No interior dos pontos xi , i=1, 2,..., N, a equação diferencial que faz a aproximação

é y ''( xi ) = p( xi ) y '( xi ) + q ( xi ) y ( xi ) + r ( xi ) . (i)

Expandindo y em um polinômio de Taylor de terceiro grau sobre xi , calculado a

xi+1 e xi−1 temos:

h2 h3 h 4 (4) +
y ( xi +1 ) = y ( xi + h ) = y ( xi ) + hy ' ( xi ) + y ' ' ( xi ) + y ' ' ' ( xi ) + y ( ξ i ) (ii),
2! 3! 4!

para algum ξi , xi < ξi + < xi +1 e

h2 h3 h 4 ( 4) −
y( xi −1 ) = y( xi − h) = y( xi ) − hy ' ( xi ) + y ' ' ( xi ) − y ' ' ' ( xi ) + y ( ξi ) (iii), para
2! 3! 4!
− −
algum ξi xi −1 < ξ i < xi , assumindo que y pertence ao intervalo [ xi −1 , xi +1 ].

Se essas equações são adicionadas, os termos envolvendo y '( xi ) e y '''( xi ) são

eliminados e a simples manipulação algébrica nos dá :

1 h 2 (4) +
[ ]
y ' ' ( xi ) = 2 y( xi +1 ) − 2 y ( xi ) + y ( xi −1 ) − [ y (ξ i ) + y ( 4 ) (ξ i − )] (iv)
h 24

O teorema do valor médio pode ser usado para simplificar a expressão acima:

1 h 2 (4)
y ' ' ( xi ) = y ( xi +1 ) − 2 y ( xi ) + y ( xi −1 ) − y ( ξ i ) (v)
h2 12

para algum ponto ξi , xi −1 < ξi < xi +1 ,que é chamada fórmula da diferença centrada para

y ''( xi ) . A fórmula da diferença centrada para y '( xi ) pode ser obtida de maneira similar e

197
resulta em

1 h2
y ' ( xi ) = y ( xi +1 ) − y ( xi −1 ) − y ' ' ' ( ηi ) (vi)
2h 6

para algum ηi ,onde xi −1 < ηi < xi +1.

O uso dessas fórmulas de diferenças centradas em nossa primeira equação (i)

resulta na equação

y ( x i +1 ) − 2 y ( x i ) + y ( x i −1 ) y ( x i +1 ) − y ( x i −1 ) h2
h 2 = p( x i )
2h
+ q ( xi ) y( xi ) + r ( xi ) −
12
[ 2 p( x i ) y ' ' ' (η i ) − y ( 4 ) (ξ i )] .
(vii)

Um método de diferenças finitas com erro de truncamentode ordem O ( h 2 ) ,

resulta pelo uso desta equação, juntamente com as condições de fronteira

y ( a ) = α , y (b ) = β de w0 = α , wn +1 = β e

2 wi − wi +1 − wi −1 wi +1 − wi −1
2 + p( xi ) + q ( xi ) wi = − r ( xi ) para cada i=1,2,...,N.
h 2h

Consideraremos a equação acima reescrita na forma

h h
− 1+ p( xi ) wi −1 + (2 + h 2 q ( xi )) wi − 1 − p( xi ) wi +1 = − h 2 r ( xi ) , o que resulta
2 2

num sistema de equações expressas em uma matriz tridiagonal N x N.

O sistema triangular tem uma solução única que obedece às condições do seguinte

teorema: Suponha que p, q e r são contínuas em [a.b]. Se q(x) ≥ 0 em [a,b], então o

sistema linear tridiagonal tem uma única solução fornecida, que h<2/L, onde L

=maxa ≤ x ≤b p ( x ) .

Deve-se notar que a hipótese do teorema garante uma única solução para o

problema de valor de fronteira, mas ele não garante que y pertence ao intervalo[a,b]. É

necessário estabelecer que y ( 4) é contínua em [a,b] para certificar que o erro de

198
truncamento tem ordem O ( h 2 ) .

A seguir apresentamos o algorítmo utilizado para calcular,como exemplo,a

aproximação da solução do problema de valor de fronteira:

2 2 sin (ln( x ))
y '' = − y' + 2 y + , 1 ≤ x ≤ 2 ,y(1)=1,y(2)=2.
x x x2

Os resultados finais serão comparados com a aplicação do método por Runge

Kutta.

9.3. Solução Algorítimica

Algoritmo para o método de solução de problemas de valor de fronteira com

diferenças finitas:

Entradas: função do problema da forma y’’=p(x)y’+q(x)y+r(x);

pontos inicial e final(a e b) do intervalo;

condições de fronteira alfa e beta;

número inteiro positivo N, que particionará o intervalo.

Saída: aproximações w(i) para y(xi), para cada i=,1,...,N+1

Passo 1 h = (b-a)/(n+1)

Passo2 x=a+h;

a1=2+h^2.q(x);

b1=-1+h.p(x)/2;

d1==-h^2.r(x)+(1+h^2.p(x)/2).a;

Passo 3 para i=2 até 1=n(passo 1) faça:

199
 x=a+ih;

ai=2+h^2.q(x);

bi=-1+h.p(x)/2;

ci=-1-h.p(x)/2;

di=-h^2.r(x);

Passo 4 x=b-h;

na=2+h^2.q(x);

cn=-1-h.p(x)/2;

dn=-h^2+(1-h.p(x)/2).ß;

l1=a1;

ul=bl/al;

Passo 5 Para i=2 até i=n-1 (passo 1) faça:

Li=ai-ci*ui-1;

ui=bi/li;

Passo 6 ln=na-cn*un-1;

zl=d1/l1;

Passo 7 Para i=2 até i=n (passo1) faça:

zi=(di-ci*zi-1)/li;

Passo 8 wn=zn;

Passo 9 Para i=n-1 até i=1 (passo -1) faça:

wi=zi-ui*wi+1;

Passo 10 Para i=0 até i=n+1 (passo 1) faça:

x=a+ih;

saida: x, wi;

200
Fim

9.3.1. Programa Fonte

/* Programa de diferen‡as lineares finitas */

/* Aproxima a solucao de um problema de valor de fronteira */

/* y''=p(x)y'+ q(x)y + r(x) , a <= x <= b , y(a)=alfa y(b)=beta; */

/* Entradas:pontos finais a,b;condicoes de fronteira alfa e beta;inteiro N*/

/* Saida:aproximacoes w(i) para y(xi) para cada i=0,1,....,N+1 */

# include <iostream.h>

# include <math.h>

# include <stdio.h>

const max=50;

double a,b,h,n,alfa,beta,wi,x;

double qx(double);

double px(double);

double rx(double);

double f(double);

int i;

void main()

double an,cn,dn,x,aux1,aux2,aux3,aux4;

double aaux[max],baux[max],caux[max],daux[max];

double l[max],u[max],z[max],w[max];

201
cout << "\n Digite o valor inicial de x: ";

cin >> a;

cout << "\n Digite o valor final de x: ";

cin >> b;

cout << "\n Digite o numero de divisäes do intervalo: ";

cin >> n;

cout << "\n Digite o valor de alfa: ";

cin >> alfa;

cout << "\n Digite o valor de beta: ";

cin >> beta;

h=(b-a)/(n+1);

x=a+h;

aaux[1]= 2+pow(h,2)*qx(x);

baux[1]= -1+h*px(x)/2;

daux[1]=(-1)*pow(h,2)*rx(x)+(1+h*px(x)/2)*alfa;

for(i=2;i<n;i++)

x=a+i*h;

aux1=2+pow(h,2)*qx(x);

aux2=(-1)+h*px(x)/2;

aux3=(-1)-h*px(x)/2;

aux4=(-1)*pow(h,2)*rx(x);

aaux[i]=aux1;

202
 baux[i]=aux2;

caux[i]=aux3;

daux[i]=aux4;

x=b-h;

an=2+pow(h,2)*qx(x);

cn=-1-h*px(x)/2;

dn=(-1)*pow(h,2)+(1-h*px(x)/2)*beta;

aaux[n]=an;

caux[n]=cn;

daux[n]=dn;

l[1]=aaux[1];

u[1]=baux[1]/aaux[1];

for(i=2;i<n;i++)

l[i]=aaux[i]-caux[i]*u[i-1];

u[i]=baux[i]/l[i];

l[n]=aaux[n]-caux[n]*u[n-1];

z[1]=daux[1]/l[1];

for(i=2;i<n+1;i++)

z[i]=(daux[i]-caux[i]*z[i-1])/l[i];

203
 w[0]=alfa;

w[n+1]=beta;

w[n]=z[n];

for(i=n-1;i>0;i--)

w[i]=z[i]-u[i]*w[i+1];

for(i=0;i<=n+1;i++)

x=a+i*h;

cout << "\n x: " << x << "\t" << " w: " << w[i] << "\t";

double px(double x)

return(-4/x);

double qx(double x)

return (-2/pow(x,2));

double rx(double x)

204
 return (2*log(x)/pow(x,2));

double f(double x)

return (px(x)+qx(x)+rx(x));

/* Programa de aproximacao da solucao de um problema de valor de fronteira */

/* -y''+ p(x)y'+ q(x)y + r(x)=0, a <= x <= b ,y(a)=alfa,y(b)=beta */

/* utilizando metodo de Runge Kutta.Seu resultado ser comparado ao resulta*/

/* do obtido no algoritmo de diferencas lineares finitas */

/* */

/* Entradas:pontos inicial e final a e b,condicoes de fronteira alfa e beta*/

/* e numero de subintervalos n. */

/* Saida:aproximacoes w(1,i) para y(xi),w(2,i) para y'(xi),para cada i, */

/* i=0,1,...,N */

# include<stdio.h>

# include<iostream.h>

# include<math.h>

const max=50;

double a,b,h,n,alfa,beta,wi,x;

double qx(double);

double px(double);

double rx(double);

205
double f(double);

int i;

void main()

double u1[max],u2[max],v1[max],v2[max],k1[max],k2[max],k3[max],k4[max];

double dk1[max],dk2[max],dk3[max],dk4[max];

double w1,w2,w10,w20;

cout << "\n Digite o valor inicial de x: ";

cin >> a;

cout << "\n Digite o valor final de x: ";

cin >> b;

cout << "\n Digite o numero de divisäes do intervalo: ";

cin >> n;

cout << "\n Digite o valor de alfa: ";

cin >> alfa;

cout << "\n Digite o valor de beta: ";

cin >> beta;

h=(b-a)/n;

u1[0]=alfa;

u2[0]=0;

v1[0]=0;

v2[0]=1;

for(i=0;i<n;i++)

206
{ /* metodo de Runge Kutta */

x=a+i*h;

k1[1]=h*u2[i];

k1[2]=h*(px(x)*u2[i]+qx(x)*u1[i]+rx(x));

k2[1]=h*(u2[i]+k1[2]/2);

k2[2]=h*(px(x+h/2)*(u2[i]+k1[2]/2)+qx(x+h/2)*(u1[i]+k1[1]/2)+rx(x+h/2));

k3[1]=h*(u2[i]+k2[2]/2);

k3[2]=h*(px(x+h/2)*(u2[i]+k2[2]/2)+qx(x+h/2)*(u1[i]+k2[1]/2)+rx(x+h/2));

k4[1]=h*(u2[i]+k3[2]);

k4[2]=h*(px(x+h)*(u2[i]+k3[2])+qx(x+h)*(u1[i]+k3[1])+rx(x+h));

u1[i+1]=u1[i]+(k1[1]+2*k2[1]+2*k3[1]+k4[1])/6;

u2[i+1]=u2[i]+(k1[2]+2*k2[2]+2*k3[2]+k4[2])/6;

dk1[1]=h*v2[i];

dk1[2]=h*(px(x)*v2[i]+qx(x)*v1[i]);

dk2[1]=h*(v2[i]+dk1[2]/2);

dk2[2]=h*(px(x+h/2)*(v2[i]+dk1[2]/2)+qx(x+h/2)*(v1[i]+dk1[1]/2));

dk3[1]=h*(v2[i]+dk2[2]/2);

dk3[2]=h*(px(x+h/2)*(v2[i]+dk2[2]/2)+qx(x+h/2)*(v1[i]+dk2[1]/2));

dk4[1]=h*(v2[i]+dk3[2]/2);

dk4[2]=h*(px(x+h)*(v2[i]+dk3[2])+qx(x+h)*(v1[i]+dk3[1]));

v1[i+1]=v1[i]+(dk1[1]+2*dk2[1]+2*dk3[1]+dk4[1])/6;

v2[i+1]=v2[i]+(dk1[2]+2*dk2[2]+2*dk3[2]+dk4[2])/6;

w10=alfa;

207
 w20=(beta-u1[n])/v1[n];

cout << "\nx0: " << a << "\t" << "u(1,i): "<< u1[0] << "\t"<< "v(1,i): "<< v1[0] << "\t"

<< "wi: " << w10;

for(i=1;i<=n;i++)

w1=u1[i]+w20*v1[i];

// w2=u2[i]+w20*v2[i];

x=a+i*h;

cout << "\nx: " << x << "\t" << "u(1,i): " << u1[i] << "\t" << "v(1,i): " << v1[i] << "\t"

<< "wi: " << w1;

double px(double x)

return(-4/x);

double qx(double x)

return (-2/pow(x,2));

double rx(double x)

return (2*log(x)/pow(x,2));

208
}

double f(double x)

return (px(x)+qx(x)+rx(x));

/*double px(double x)

return(-2/x);

double qx(double x)

return (2/pow(x,2));

double rx(double x)

return (sin(log(x))/pow(x,2));

double f(double x)

return (px(x)+qx(x)+rx(x));

}*/

9.3.2. Exemplo

209
Calcular o problema:

Com 1<x<2, y(1)=0.5, y(2)=ln2, usando h=0.05 e comparando com R.K)

4 2 2
y' ' = − y '− 2 y + 2 ln x
x x x

9.3.2.1. Tabelas e Gráficos

0.80

0.40

0.00

-0.40

-0.80

0.80 1.20 1.60 2.00

210
valores usando dif. usando
Iniciais finitas R.K
1 -0.5 -0.5
1.05 -0.337845 -0.336338
1.1 -0.204267 -0.21845
1.15 -0.092227 -89165
1.2 0.003246 0.006726
1.25 0.085738 0.089485
1.3 0.157893 0.161801
1.35 0.221694 0.22569
1.4 0.278654 0.282686
1.45 0.329944 0.333974
1.5 0.376481 0.380485
1.55 0.418997 0.422955
1.6 0.458076 0.461976
1.65 0.494194 0.498028
1.7 0.527741 0.531503
1.75 0.55904 0.562725
1.8 0.588358 0.591965
1.85 0.615922 0.61945
1.9 0.641922 0.64537
1.95 0.6652 0.669899
2 0.693147 0.693147

9.4. Conclusão

211
 Podemos notar pela comparação dos métodos que os resultados obtidos com a

aplicação do programa de diferenças finitas é menos acurado que aqueles obtidos pela

aplicação do método que utiliza Runge Kutta. Isso pode ser explicado pelo fato do

método que utiliza a técnica de Runge Kutta possuir um erro de truncamento da ordem

O ( h 4 ) , enquanto o método de diferenças finitas possui um erro de truncamento da ordem

de O ( h 2 ) .

Podería-se desenvolver o método de diferenças finitas com uma precisão mais

acurada,através do uso da série de Taylor de quinta ordem (o que resultaria num erro de

truncamento de h 4 ), mas isto iria requerer usar múltiplos não somente de y ( xi +1 ) e

y ( xi −1 ) ,mas também de y ( xi + 2 ) e y ( xi − 2 ) ,nas fórmulas de aproximação para y ''( xi ) e

y '( xi ) ,o que dificultaria a implementação do loop i=0 até =N.Além do mais a resolução

do sistema de equações não seria da forma tridiagonal,e a solução do sistema passaria a

requerer muitos outros cálculos,além de outras dificuldades.

212