You are on page 1of 9

INSTITUTO POLITCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERA MECNICA Y ELCTRICA


UNIDAD PROFESIONAL ADOLFO LPEZ MATEOS
INGENIERA EN COMUNICACIONES Y ELECTRNICA
ACADEMIA DE COMPUTACIN
ANLISIS NUMRICO
PROFESOR UGALDE MIRANDA ENRIQUE
GRUPO 4CV3
ALUMNOS:
Soto Espinosa Pedro Rodolfo
18 de febrero de 2015

2013302063

METODO DE RUNGE-KUTTA.
Soto Espinosa Pedro Rodolfo
2013302063
Resumen.
Los mtodos de Taylor tienen la propiedad de un error local de truncamiento de
orden superior, pero la desventaja de requerir el clculo y la evaluacin de las
derivadas de f(t, y). Esto resulta algo lento y complicado, en la mayora de los
problemas, razn por la cual, en la prctica casi no se utilizan. El mtodo de Euler,
lamentablemente requiere de un paso muy pequeo para una precisin razonable.
Los mtodos de Runge kutta tienen el error local de truncamiento del mismo orden
que los mtodos de Taylor, pero prescinden del clculo y evaluacin de las
derivadas de la funcin f(t, y).
Justificacin.
En anlisis numrico, los mtodos de Runge-Kutta son un conjunto de mtodos
genricos iterativos, explcitos e implcitos, de resolucin numrica de ecuaciones
diferenciales. Este conjunto de mtodos fue inicialmente desarrollado alrededor
del ao 1900 por los matemticos C. Runge y M. W. Kutta.
Los mtodos de Runge-Kutta (RK) son un conjuntos de mtodos iterativos
(implcitos y explcitos) para la aproximacin de soluciones de ecuaciones
diferenciales ordinarias, concretamente, del problema de valor inicial.
Marco Terico.
El mtodo de Runge-Kutta no es slo un nico mtodo, sino una importante familia
de mtodos iterativos, tanto implcitos como explcitos, para aproximar las
soluciones deecuaciones diferenciales ordinarias (E.D.Os); estas tcnicas fueron
desarrolladas alrededor de 1900 por los matemticos alemanes Carl David Tolm
Runge y Martin Wilhelm Kutta.
Se presenta de nuevo el problema de valor inicial cuya solucin se intenta
aproximar:
{

dy
=f ( t , y ) ; a<t <b
dt

{ y ( a ) =

(1)

Como en los mtodos anteriores, se determina primero la malla {t0, t1, ... , tN} de
paso h, donde t0 = a y tN = b. En estos puntos es donde se va a obtener la
aproximacin de la solucin.

En esencia, los mtodos de Runge-Kutta son generalizaciones de la frmula


bsica de Euler y i+1= y1 +hf (t i , y i) en los que el valor de la funcin f se
reemplaza por un promedio ponderado de valores de f en el intervalo ti t ti+1,
es decir,
y i+1= y1 +h (w1 k 1 + w2 k 2+ +w m k m )

(2)

En esta expresin las ponderaciones wi, i = 1,..., m son constantes para las que en
general se pide que su suma sea igual a 1, es decir, w1 + w2 +... + wm = 1, y cada
kj es la funcin f evaluada en un punto seleccionado (t, y) para el cual ti t ti+1.
Se mostrar que los kj se definen en forma recursiva.
Se define como orden del mtodo al nmero m, es decir, a la cantidad de trminos
que se usan en el promedio ponderado.
Runge-Kutta de primer orden
Si m = 1, entonces se toma w1 = 1 y la frmula (2) resulta
y i+1= yi +h k 1

(3)

Igualando esta frmula al desarrollo de Taylor de orden 1 de la funcin y (t),


alrededor del punto ti, y calculado en el punto ti+1:
t
'
y ( i +1) y ( t i ) + y ( t i ) h

Y teniendo en cuenta que


frmula de Euler

(4)

t
y ( i+1) y ( t i ) , resulta k1= f(ti, yi), obteniendo as la

y i+1= yi +hf (t i , y i) . Por lo tanto, se dice tambin que el mtodo

de Euler es un mtodo de Runge Kutta de primer orden.


Mtodos de Runge-Kutta de cuarto orden
Un miembro de la familia de los mtodos Runge-Kutta es usado tan comnmente
que a menudo es referenciado como RK4 o como el mtodo Runge-Kutta.
Definiendo un problema de valor inicial como:
Entonces el mtodo RK4 para este problema est dado por la siguiente ecuacin:

Donde

As, el siguiente valor (yn+1) es determinado por el presente valor (yn) ms el


producto del tamao del intervalo (h) por una pendiente estimada. La pendiente es
un promedio ponderado de pendientes, donde
es la pendiente al principio del
intervalo,
es la pendiente en el punto medio del intervalo, usando
para
determinar el valor de y en el punto
usando el mtodo de Euler.
es otra
vez la pendiente del punto medio, pero ahora usando
para determinar el valor
de y;
es la pendiente al final del intervalo, con el valor de y determinado por .
Promediando las cuatro pendientes, se le asigna mayor peso a las pendientes en
el punto medio:

Esta forma del mtodo de Runge-Kutta, es un mtodo de cuarto orden lo cual


significa que el error por paso es del orden de
acumulado tiene el orden
orden de

, mientras que el error total

. Por lo tanto, la convergencia del mtodo es del

, razn por la cual es usado en los mtodos computacionales.

Desarrollo del Mtodo


Sea
una ecuacin diferencial ordinaria, con
donde
conjunto abierto, junto con la condicin de que el valor inicial de sea

es un

Entonces el mtodo RK (de orden s) tiene la siguiente expresin, en su forma ms


general:
,
Donde h es el paso por iteracin, o lo que es lo mismo, el incremento
entre
los sucesivos puntos
y
. Los coeficientes son trminos de aproximacin
intermedios, evaluados en de manera local

Con
coeficientes propios del esquema numrico elegido, dependiente de
la regla de cuadratura utilizada. Los esquemas Runge-Kutta pueden ser explcitos
o implcitos dependiendo de las constantes
del esquema. Si esta matriz es
triangular inferior con todos los elementos de la diagonal principal iguales a cero;
es decir,
para
, los esquemas son explcitos.

Problema Resuelto
Esquema Runge-Kutta de dos etapas, una en
(t,y(t)) en la primera etapa es:
Para estimar (t,y) en

y otra en

se usa un esquema Euler

Con estos valores de , se sustituyen en la ecuacin

de manera que se obtiene la expresin:

Los coeficientes propios de este esquema son:


Cdigo del programa en c
#include<iostream.h>
#include<conio.h>
#include<iomanip.h>
#include<math.h>
//Se debe ingresar X0=0; Y0=1; Xf=1; N=10
/**********************Se ingresa la funcion****************************/
float func(float x, float y){
return 0.5*(1+x)*pow(y,2);
}
/**********************Reportar los Datos******************************/
void reportar(float x, float y, int i)
{cout<<setiosflags(ios::showpoint | ios::fixed);
cout<<setiosflags(ios::right);
cout.precision(4);
cout<<setw(10)<<i<<setw(15)<<x<<setw(15)<<y<<endl;
}
/**********************Reportar los Datos******************************/
int menu()
{int opc;
do
{clrscr();
cout<<setw(50)<<"SELECCIONE OPCION\n";

cout<<setw(50)<<"-----------------\n"<<endl;
cout<<"1.Metodo de Euler"<<endl;
cout<<"2.Metodo de Runge -Kutta"<<endl;
cout<<"3.Salir"<<endl;
cout<<"\nSeleccione Opcion: ";cin>>opc;
}while(opc<1 || opc>3);
return opc;
}
/**********************Metodo de Euler******************************/
void Euler(){
float x0,y0,xf,yf,h;
int n,i;
clrscr();
cout<<setw(50)<<"Metodo de Integracion de Euler"<<endl;
cout<<setw(50)<<"------------------------------"<<endl<<endl;
cout<<"Ingrese el valor de x0: ";
cin>>x0;
cout<<"Ingrese el valor de y0: ";
cin>>y0;
cout<<"ingrese el valor de xf: ";
cin>>xf;
do{
cout<<"Ingrese el numero de subintervalos a emplear: ";
cin>>n;
}while(n<=0);
h=(xf-x0)/n;
cout<<endl;
cout<<setw(10)<<"I"<<setw(15)<<"Xi"<<setw(15)<<"Yi"<<endl;
cout<<setw(10)<<"-"<<setw(15)<<"--"<<setw(15)<<"--"<<endl;
for(i=1;i<=n;i++)
{ y0=y0+h*func(x0,y0);
x0=x0+h;
reportar(x0,y0,i);
}
cout<<"\nEl valor de Yf: "<<y0<<endl;
getch();
}
/**********************Metodo de Runge Kutta******************************/
void Kutta(){
float x0,y0,xf,yf,h,k1,k2,k3,k4;
int n,i;
clrscr();
cout<<setw(50)<<"Metodo de Runge - Kutta"<<endl;

cout<<setw(50)<<"-----------------------"<<endl<<endl;
cout<<"Ingrese el valor de x0: ";
cin>>x0;
cout<<"Ingrese el valor de y0: ";
cin>>y0;
cout<<"ingrese el valor de xf: ";
cin>>xf;
do{
cout<<"Ingrese el numero de subintervalos a emplear: ";
cin>>n;
}while(n<=0);
h=(xf-x0)/n;
cout<<endl;
cout<<setw(10)<<"I"<<setw(15)<<"Xi"<<setw(15)<<"Yi"<<endl;
cout<<setw(10)<<"-"<<setw(15)<<"--"<<setw(15)<<"--"<<endl;
for(i=1;i<=n;i++)
{ k1=func(x0,y0);
k2=func(x0+h/2,y0+h*k1/2);
k3=func(x0+h/2,y0+h*k2/2);
k4=func(x0+h,y0+h*k3);
y0=y0+(k1+2*k2+2*k3+k4)*h/6;
x0=x0+h;
reportar(x0,y0,i);
}
cout<<"El valor de Yf: "<<y0<<endl;
getch();
}
/**********************Terminar******************************/
void terminar()
{cout<<"\t\t\t\tSalir del Programa\n";
cout<<"\t\t\t\t------------------\n\n";
cout<<"Gracias por usar el programa"<<endl<<endl;
}
/**********************Funcion Principal******************************/
void main (void)
{int opc;
do
{clrscr();
opc=menu();
clrscr();
switch(opc)
{case 1: clrscr();Euler(); break;
case 2: clrscr();Kutta();break;

case 3: clrscr();terminar();break;
}
getch();
}
while(opc!=3);
getch();
}
Conclusiones:
el anlisis y solucin de los problemas de valor inicial de ecuaciones diferenciales
ordinarias (EDO), estos son una extensin del mtodo de Euler para resolver las
(EDOS), pero con un orden de exactitud ms alto que este.
BIBLIOGRAFIA:
http://es.wikipedia.org/wiki/M%C3%A9todo_de_Runge-Kutta
http://es.slideshare.net/marticalu001/mtodo-runge-kutta-computacin-aplicada
http://www.frsn.utn.edu.ar/gie/an/mnedo/34_RK.html

You might also like