Está en la página 1de 66

MONOGRAFIA DE METODOS NUMERICOS

METODO DE LA BISECCION
En matemtica, el mtodo de biseccin es un algoritmo de bsqueda de races que trabaja dividiendo el intervalo a la mitad y selecionando el subintervalo que tiene la raz. Supongase que queremos resolver la ecuacin f(x) = 0 (donde f es continua. Dados dos puntos a y b tal que f(a) y f(b) tengan signos distintos, sabemos por el Teorema de Bolzano que f debe tener, al menos, una raz en el intervalo [a, b]. El mtodo de biseccin divide el intervalo en dos, usando un tercer punto c = (a+b) / 2. En este momento, existen dos posibilidades: f(a) y f(c), f(c) y f(b) tienen distinto signo. El algoritmo de biseccin se aplica al subintervalo donde el cambio de signo ocurre. El mtodo de biseccin es menos eficiente que el mtodo de Newton, pero es mucho ms seguro asegurar la convergencia. Si f es una funcin continua en el intervalo [a, b] y f(a)f(b) < 0, entonces este mtodo converge a la raz de f. De hecho, una cota del error absoluto es:

en la nsima iteracin. La biseccin converge linealmente, por lo cual es un poco lento. Sin embargo, se garantiza la convergencia si f(a) y f(b) tienen distinto signo.

Unas cuantas iteraciones del mtodo de biseccin aplicadas en un intervalo [a1;b1]. El punto rojo es la raz de la funcin.

DIAGRAMA DE FLUJO :

INICIO

LEER f(X),a,b,E V
f(a)*f(b)<0

lb - al>E ESCRIBIR No existe raiz


F

x=(a+b)/2 v

f(x)=0 f(a)*f(x)<0

a=b b=x

a=x

ESCRIBIR
X

FIN

PROGRAMACION DEL METODO: GUIDE:

CODIFICACION:

function pushbutton1_Callback(hObject, eventdata, handles) % $$$$$____CODIFICACION DEL METODO DE BISECCION ____$$$$$$ f=inline(get(handles.edit1,'string')); a=str2double(get(handles.edit2,'string')); b=str2double(get(handles.edit3,'string')); E=str2double(get(handles.edit4,'string')); if f(a)*f(b)<0 while abs(b-a)>E x=(a+b)/2; if f(a)*f(x)==0 a=b; else if f(a)*f(x)<0 b=x; else a=x; end end end else set(handles.edit5,'string','No existe Raiz') end set(handles.edit5,'string',x)

function pushbutton2_Callback(hObject, eventdata, handles) figure(1) f=inline(get(handles.edit1,'string')); ezplot(f);grid on function pushbutton3_Callback(hObject, eventdata, handles) close(biseccion)

MTODO DEL PUNTO FIJO.


Este mtodo aunque no es el mas sencillo, ni el mas rpido, es til ya que es la base de los dems mtodos. Bsicamente se da un valor y este se evala en una funcin previamente calculada (llamada tambin funcin equivalente). Despus en base al resultado obtenido se busca el error mediante

/xi x1 + 1/<=E si esto se cumple se encontr la raz si no, se evala el nuevo valor en la funcin equivalente as hasta llegar al error.

Este mtodo funciona de la siguiente manera:

Algoritmo
1.- Dada una funcin f(x) se localiza su equivalente.

2..- Despus se asigna un valor inicial que es x0.

3.- Se asigna un valor de error ( estn pequeo como lo quiera el usuario).

4.- Se sustituye x0 en la funcin equivalente. Ese valor es x1 y se compara con el error deseado. Si el error que se calculo es igual o menor al que dio el usuario se encontr la raz.

El mtodo del punto fijo se basa en que una raz de la ecuacin f ( x ) = 0 ser un punto fijo de la ecuacin g ( x ) = x siempre que g ( x ) = x f ( x ) o g ( x ) = x + f ( x ) .

Podemos construir una sucesin que tienda al punto fijo de la ecuacin g ( x ) = x , o lo que es lo mismo a la solucin de la ecuacin f ( x ) = 0 . Para ello consideramos la sucesin:
x0 dado x n = f ( xn 1 )

se n 1

Caractersticas
El mtodo presenta dos inconvenientes:

La sucesin debe estar bien construida, es decir, cada trmino debe pertenecer al dominio de la funcin f (x ) para poder calcular el trmino siguiente. La sucesin no siempre es convergente aunque est bien construida

Es interesante ver como para una misma funcin

f (x ) podemos tomar distintas funciones g (x ) y el mtodo puede ser


convergente con una y no serlo con otras.

DIAGRAMA DE FLUJO:

IN IC IO

LEE R f(x ),g (x ),X 0 ,E

X 1 = g (X 0 )

lX 1 -X 0 l> E
V

X0=X1 X 1 = g (X )

E S C R IB IR X1 F IN

PROGRAMACION DEL METODO: GUIDE:

CODIFICACION: function pushbutton1_Callback(hObject, eventdata, handles)


f=inline(get(handles.edit1,'string')); g=inline(get(handles.edit2,'string')); X0=str2double(get(handles.edit3,'string')); E=str2double(get(handles.edit4,'string')); X1=g(X0); while abs(X1-X0)>E X0=X1; X1=g(X0); end set(handles.edit5,'string',X1);

function pushbutton2_Callback(hObject, eventdata, handles) % $$$$====GRAFICA DE LA FUNCION====$$$$ figure(1) f=inline(get(handles.edit1,'string')); ezplot(f);grid on

function pushbutton3_Callback(hObject, eventdata, handles) close(puntofijo)

MTODO DE NEWTON-RAPHSON
Este mtodo parte de una aproximacin inicial x0 y obtiene una aproximacin mejor, x1, dada por la frmula: (29)

La expresin anterior puede derivarse a partir de un desarrollo en serie de Taylor. Efectivamente, sea r un cero de f y sea x una aproximacin a r tal que r=x+h. Si f'' existe y es continua, por el teorema de Taylor tenemos: 0 = f(r) = f(x+h) = f(x) + hf'(x) + O(h2) en donde h=r-x. Si x est prximo a r (es decir hes pequea), es razonable ignorar el trmino O(h2): 0 = f(x) + hf'(x) por lo que obtenemos la siguiente expresin para h: (32) (31) (30)

A partir de la ecuacin (32) y teniendo en cuenta que r=x+h es fcil derivar la ecuacin (29).

Figure: Interpretacin geomtrica del mtodo de Newton. [scale=0.9]eps/new-1 El mtodo de Newton tiene una interpretacin geomtrica sencilla, como se puede apreciar del anlisis de la figura (6). De hecho, el mtodo de Newton consiste en una linealizacin de la funcin, es decir, f se reemplaza por una recta tal que contiene al punto (x0,f(x0)) y cuya pendiente coincide con la derivada de la funcin en el punto, f'(x0). La nueva aproximacin a la raz, x1, se obtiene de la interseccin de la funcin linear con el eje X de ordenadas. Veamos como podemos obtener la ecuacin (29) a partir de lo dicho en el prrafo anterior. La ecuacin de la recta que pasa por el punto (x0,f(x0)) y de pendiente f'(x0) es: y - f(x0) = f'(x0)(x-x0) de donde, haciendo y=0 y despejando x obtenemos la ecuacin de Newton-Raphson (29). (33)

Figure: Dos situaciones en las que el mtodo de Newton no funciona adecuadamente: (a) el mtodo no alcanza la convergencia y (b) el mtodo converge hacia un punto que no es un cero de la ecuacin. [scale=0.9]eps/new-2 El mtodo de Newton es muy rpido y eficiente ya que la convergencia es de tipo cuadrtico (el nmero de cifras significativas se duplica en cada iteracin). Sin embargo, la convergencia depende en gran medida de la forma que adopta la funcin en las proximidades del punto de iteracin. En la figura (7) se muestran dos situaciones en las que este mtodo no es capaz de alcanzar la convergencia (figura (7a)) o bien converge hacia un punto que no es un cero de la ecuacin (figura (7b)).

DIAGRAMA DE FLUJO :

INICIO

LEER f(X),f'(X),X,E X1=X0 - f(X0)/f'(X0)

lx1-x0l >E
V

X0=X1 X1=X0 - f(X0)/f'(X0)

ESCRIBIR X1

FIN

PROGRAMACION DEL METODO: GUIDE:

CODIFICACION:
function pushbutton1_Callback(hObject, eventdata, handles) f=inline(get(handles.edit1,'string')); df=inline(get(handles.edit2,'string')); X0=str2double(get(handles.edit3,'string')); E=str2double(get(handles.edit4,'string')); X1=X0-f(X0)/(df(X0)); while abs(X1-X0)>E X0=X1; X1=X0-f(X0)/(df(X0)); end set(handles.edit5,'string',X1); function pushbutton2_Callback(hObject, eventdata, handles) % $$$$====GRAFICA DE LA FUNCION====$$$$ figure(1) f=inline(get(handles.edit1,'string')); ezplot(f);grid on function pushbutton3_Callback(hObject, eventdata, handles) close(newtonrapshon1)

Mtodo de la secante
El principal inconveniente del mtodo de Newton estriba en que requiere conocer el valor de la primera derivada de la funcin en el punto. Sin embargo, la forma funcional de f(x) dificulta en ocasiones el clculo de la derivada. En estos casos es ms til emplear el mtodo de la secante. El mtodo de la secante parte de dos puntos (y no slo uno como el mtodo de Newton) y estima la tangente (es decir, la pendiente de la recta) por una aproximacin de acuerdo con la expresin: (34)

Sustituyendo esta expresin en la ecuacin (29) del mtodo de Newton, obtenemos la expresin del mtodo de la secante que nos proporciona el siguiente punto de iteracin: (35)

Figure: Representacin geomtrica del mtodo de la secante. [scale=0.9]eps/secante En la siguiente iteracin, emplearemos los puntos x1 y x2para estimar un nuevo punto ms prximo a la raz de acuerdo con la ecuacin (35). En la figura (8) se representa geomtricamente este mtodo. En general, el mtodo de la secante presenta las mismas ventajas y limitaciones que el mtodo de Newton-Raphson explicado anteriormente

DIAGRAMA DE FLUJO:

I N IC IO

LEER X 0 ,X 1 ,f(X ),E

l X 1 -X 0 l > E

X 2 = X 1 - (X 1 -X 0 )* f(X 1 )/ (f(X 1 )-f(X 0 ))

X0 = X1 X1 = X2

E S C R I B IR X1

F IN

PROGRAMACION DEL METODO: GUIDE:

CODIFICACION:
function pushbutton1_Callback(hObject, eventdata, handles) f=inline(get(handles.edit1,'string')); X0=str2double(get(handles.edit2,'string')); X1=str2double(get(handles.edit3,'string')); E=str2double(get(handles.edit4,'string')); while abs(X1-X0)>E X2=X1-((X1-X0)*f(X1))/(f(X1)-f(X0)) X0=X1 X1=X2 end set(handles.edit5,'string',X2);

function pushbutton2_Callback(hObject, eventdata, handles) % $$$$====GRAFICA DE LA FUNCION====$$$$ figure(1) f=inline(get(handles.edit1,'string')); ezplot(f);grid on

function pushbutton3_Callback(hObject, eventdata, handles) close(secante)

METODO

DE

GAUSS - JORDAN

Este mtodo utiliza las mismas tcnicas de eliminacin Gaussiana (incluyendo el pivoteo), pero con el objetivo de finalizar con una matriz de la siguiente forma:

donde

I n es la matriz identidad de nxn .

Para lograr esto, se usa la tcnica del pivoteo con la nica diferencia que el pivote se usa para hacer ceros hacia abajo y hacia arriba. Ejemplo 1: mtodo de Gauss-Jordan para resolver el siguiente sistema: Usar el

Solucin.

Comenzamos con la matriz aumentada:

Procedemos a hacer el primer pivoteo, y para ello, intercambiamos los renglones 1 y 2:

y haciendo ceros debajo del pivote, obtenemos:

Ahora, para colocar adecuadamente el segundo pivote intercambiamos los renglones 2 y 3:

Para hacer ceros arriba del pivote 1.25, multiplicamos el rengln 2 por 1.25 y se lo sumamos al rengln 1; para hacer ceros debajo del mismo pivote, multiplicamos al mismo rengln 2 por
0.5 1.25

y se lo sumamos al rengln 3 . Todo esto nos da:

Ahora procedemos a hacer ceros arriba del pivote 0.09 . el rengln 3 rengln 3 por por
1.9 0.09 0.85 0.09

Para ello, multiplicamos

y se lo sumamos al rengln 2; igualmente multiplicamos el Todo esto nos da:

y se lo sumamos al rengln 1.

Finalmente para hacer los 1s ( unos ) en la diagonal principal, multiplicamos los renglones 1 , 2, y 3 por entonces la matriz final:

1 1 , 2 1.25 y

1 0.09 , respectivamente.

Obtenemos

La cual nos da la solucin del sistema de ecuaciones:

INICIO

DIAGRAMA DE FLUJO:

LEER

n , aij

i=0,n,1

divisor = aii

j = i , n + 1, 1

aij = aij /divisor

k=1,n,1

i~=k pivote=a(k,i)

j = i, n, 1

akj = akj - pivote* aij

ESCRIBIR

ai,n+1
FIN

PROGRAMACION DEL METODO: GUIDE:

CODIFICACION: function varargout = pushbutton1_Callback(h, eventdata, handles, varargin) a=str2num(get(handles.edit3,'string')); [m,n]=size(a); for i=1:m divisor=a(i,i); for j=i:n a(i,j)=a(i,j)/divisor; end for k=1:m if i~=k pivote=a(k,i);

for j=i:n a(k,j)=a(k,j)-pivote*a(i,j); end end end end for i=1:m x(i)=a(i,n); end x=x'; t=1:m; t=t' cadena=''; for t=1:m cad=sprintf('x%d=%6.2f',t,x(t)); cadena=[cadena;cad]; end set(handles.edit4,'string',cadena) % -------------------------------------------------------------------function varargout = pushbutton2_Callback(h, eventdata, handles, varargin) set(handles.edit3,'string',''); set(handles.edit4,'string',''); % -------------------------------------------------------------------function varargout = pushbutton3_Callback(h, eventdata, handles, varargin) close(gausjordan)

METODO DE GAUSS-SEIDEL
El mtodo de Gauss-Seidel, es un mtodo iterativo y por lo mismo, resulta ser un mtodo bastante eficiente. Comenzamos con nuestro sistema de ecuaciones:

De la ecuacin 1 despejemos ecuacin n despejemos

x1 , de la ecuacin 2 despejemos x 2 , , de la

x n . Esto nos da el siguiente conjunto de ecuaciones:

Este ltimo conjunto de ecuaciones son las que forman nuestras frmulas iterativas. Para comenzar el proceso iterativo, le damos el valor de cero a las variables x 2 , L , x n ; esto nos dar un primer valor para tenemos que:

x1 . Ms precisamente,

x1 en la ecuacin 2, y las variables x3 , L , x n siguen teniendo el valor de cero. Esto nos da el siguiente valor para x 2 :
Enseguida, sustitumos este valor de

Estos ltimos valores de

x1 y x 2 , los sustitumos en la ecuacin 3, mientras

que x 4 , L , x n siguen teniendo el valor de cero; y as sucesivamente hasta llegar a la ltima ecuacin. Todo este paso, nos arrojar una lista de primeros valores para nuestras incgnitas, la cual conforma nuestro primer paso en el proceso iterativo. Digamos que tenemos:

Volvemos a repetir el proceso, pero ahora sustituyendo estos ltimos datos en vez de ceros como al inicio, obtendremos una segunda lista de valores para cada una de las incgnitas. Digamos que ahora tenemos:

En este momento, podemos calcular los errores aproximados relativos, respecto a cada una de las incgnitas. As, tenemos la lista de errores como sigue:

El proceso se vuelve a repetir hasta que:

donde

s es una cota suficiente prefijada

INICIO

DIAGRAMA DE FLUJO:

LEER

N, m , aij, bi, vi

K = 1, m, 1

i = 1, n, 1
Xi = Vi

i = 1, n, 1
s=0

j=1, n, 1

j ~= 1

s = s + aij*xj

vi = (bi-s)/aii Xi = vi

i = 1, n, 1
ESCRIBIR vi

FIN

PROGRAMACION DEL METODO: GUIDE:

CODIFICACION:
function varargout = pushbutton1_Callback(h, eventdata, handles, varargin)
m=str2double(get(handles.edit1,'string')); v=str2num(get(handles.edit2,'string')); a=str2num(get(handles.edit3,'string')); b=str2num(get(handles.edit4,'string')); [n,n]=size(a); cad1=''; for k=1:m for i=1:n x(i)=v(i); end for i=1:n s=0; for j=1:n if j~=i s=s+a(i,j)*x(j);

end end v(i)=(b(i)-s)/a(i,i); x(i)=v(i); end for t=1:n cad2=sprintf(' x%d=%10.8f ',t,x(t)); cad1=[cad1,cad2]; end cad2=sprintf('\n'); cad1=[cad1,cad2]; end set(handles.edit5,'string',cad1) % -------------------------------------------------------------------function varargout = pushbutton2_Callback(h, eventdata, handles, varargin) set(handles.edit1,'string',''); set(handles.edit2,'string',''); set(handles.edit3,'string','');

set(handles.edit4,'string',''); set(handles.edit5,'string','');

POLINOMIO DE INTERPOLACIN DE LAGRANGE Nuevamente tenemos los datos :

El polinomio de interpolacin de Lagrange se plantea como sigue:


P( x) = y0l0 ( x) + y1l1 ( x) + L + ynln ( x)

Donde los polinomios li (x) se llaman los polinomios de Lagrange, correspondientes a la tabla de datos. Como se debe satisfacer que P( x0 ) = y0 , esto se cumple si l0 ( x0 ) = 1 y li ( x0 ) = 0 para toda i 0 . Como se debe satisfacer que P( x1 ) = y1 , esto se cumple si l1 ( x1 ) = 1 y li ( x1 ) = 0 para toda i 1 .

Y as sucesivamente, veremos finalmente que la condicin Pn ( xn ) = yn se cumple si ln ( xn ) = 1 y li ( xn ) = 0 para toda i n . Esto nos sugiere como plantear los polinomios de Lagrange. Para ser ms claros, analicemos detenidamente el polinomio l0 ( x) . De acuerdo al anlisis anterior vemos que deben cumplirse las siguientes condiciones para l0 ( x) :
l0 ( x0 ) = 1 y l0 ( x j ) = 0 , para toda j 0 Por lo tanto, planteamos l0 ( x) como sigue: lo ( x ) = c( x x1 )( x x2 )L( x xn ) Con esto se cumple la segunda condicin sobre l0 ( x) . La

constante c se determinar para hacer que se cumpla la primera condicin:


l0 ( x0 ) = 1 1 = c( x0 x1 )( x0 x2 )L ( x0 xn ) 1 c= ( x0 x1 )( x0 x2 )L( x0 xn )

Por lo tanto el polinomio l0 ( x) queda definido como:


l0 ( x ) =

( x x1 )( x x2 )L( x xn ) ( x0 x1 )( x0 x2 )L( x0 xn )

Anlogamente se puede deducir que:


l j (x ) =

(x x )
i

(x
i j

i j

xi )

, para j = 1,K, n

MTODO DE LAGRANGE INICIO

Leer n, x

Xi

S=0

K = 0, n, 1

Num = 1 Den = 1 i = 0, n, 1

i=k

Num= Num*(X-Xi) Den=Den*(Xk-Xi)

Lk=Num/Den

S = S + Lk * f(Xk)

Escribir S

Fin

PROGRAMACION DEL METODO : GUIDE:

CODIFICACION:
function varargout = pushbutton1_Callback(h, eventdata, handles, varargin) x=str2num(get(handles.edit2,'string')); n=length(x); f=inline(get(handles.edit1,'string')); P=str2double(get(handles.edit3,'string')); S=0; for k=1:n Num=1; Dem=1; for i=1:n if k~=i

Num=Num*(P-x(i)); Dem=Dem*(x(k)-x(i)); end L=Num/Dem; end S=S+L*f(x(k)); end set(handles.edit4,'string',S)

% -------------------------------------------------------------------function varargout = pushbutton2_Callback(h, eventdata, handles, varargin) x=str2num(get(handles.edit2,'string')); f=inline(get(handles.edit1,'string')); ezplot(f),grid on

METODO DE LOS MINIMOS CUADRADOS


Supongamos que hemos medido un conjunto de pares de datos (xi, yi) en una experiencia, por ejemplo, la posicin de un mvil en ciertos instantes de tiempo. Queremos obtener una funcin y=f(x) que se ajuste lo mejor posible a los valores experimentales. Se pueden ensayar muchas funciones, rectas, polinomios, funciones potenciales o logartmicas. Una vez establecido la funcin a ajustar se determinan sus parmetros, en el caso de un polinomio, sern los coeficientes del polinomio de modo que los datos experimentales se desven lo menos posible de la frmula emprica. La funcin ms sencilla es la funcin lineal y=ax+b que hemos tratado en la pgina anterior. El procedimiento de ajustar los datos experimentales a una lnea recta se denomina regresin lineal

Polinomio aproximador Queremos aproximar un polinomio de grado n, a un conjunto de m pares de datos (xi, yi) de modo que n m. Sea el polinomio P(x)=a0+a1x+a2x2+...anxn Se calcula la cantidad

Para obtener los valores de los coeficientes del polinomio aproximador se tienen que determinar los valores de los coeficientes a0, a1, a2, ...an de forma que la cantidad S tome un valor mnimo. Hagamos las derivadas parciales de S respecto de a0, a1, a2, ...an iguales a cero

(1) Obtenemos un sistema de n+1 ecuaciones con n+1 incgnitas, a0, a1, a2, ...an Ejemplo: Supongamos que tenemos 4 pares de datos y que queremos ajustarlos al polinomio de segundo grado y=a0+a1x+a2x2 x y x0 y0 x1 y1 x2 y2 x3 y3

Las ecuaciones (1) se escribirn

agrupando trminos

Volvamos al sistema de n+1 ecuaciones con n+1 incgnitas. Introduzcamos las expresiones

(2) Se obtiene el siguiente sistema de n+1 ecuaciones con n+1 incgnitas

(3) Si todos los puntos son distintos, el sistema de ecuaciones tiene una solucin nica.

PROGRAMACION DEL METODO: GUIDE:

CODIFICACION :
function varargout = pushbutton1_Callback(h, eventdata, handles, varargin) n=str2double(get (handles.edit1,'string')); x=str2num(get(handles.edit2,'string')); y=str2num(get(handles.edit3,'string')); A11=0; A12=0; A22=n B1=0; B2=0;

for i=1:n;1 for j=0,1,1 A11=A11+(x(i)*x(i)) A12=A12+(x(i)) A21=A12 A22=n B1=B1+(x(i))*(y(i)) B2=B2+(y(i)) end end a=(B1*A22-B2*A12)/(A11*A22-A12*A21) b=(A11*B2-A21*B1)/(A11*A22-A12*A21) set(handles.edit4,'string',a); set(handles.edit5,'string',b); % -------------------------------------------------------------------function varargout = pushbutton2_Callback(h, eventdata, handles, varargin) close(MinimosCuadrados); % -------------------------------------------------------------------function varargout = pushbutton3_Callback(h, eventdata, handles, varargin) n=str2double(get (handles.edit1,'string')); x=str2num(get(handles.edit2,'string')); y=str2num(get(handles.edit3,'string')); [nu,m2]=size(x) [nv,m2]=size(y) A11=0; A12=0; A22=n B1=0; B2=0; for i=1:n; for j=0,1,1 A11=A11+(x(i)*x(i)) A12=A12+(x(i)) A21=A12 A22=n B1=B1+(x(i))*(y(i)) B2=B2+(y(i)) end end a=(B1*A22-B2*A12)/(A11*A22-A12*A21) b=(A11*B2-A21*B1)/(A11*A22-A12*A21)

set(handles.edit4,'string',a); set(handles.edit5,'string',b); Y=a*x+b plot(Y),grid % -------------------------------------------------------------------function varargout = pushbutton4_Callback(h, eventdata, handles, varargin) set(handles.edit1,'string',''); set(handles.edit2,'string',''); set(handles.edit3,'string',''); set(handles.edit4,'string',''); set(handles.edit5,'string','');

REGLA DEL TRAPECIO


Corresponde al caso donde , es decir :

donde datos:

es un polinomio de interpolacin (obviamente de grado 1) para los

Del captulo anterior, sabemos que este polinomio de interpolacin es:

Integrando este polinomio, tenemos que:

Por lo tanto, tenemos que:

Que es la conocida Regla del Trapecio. Este nombre se debe a la interpretacin geomtrica que le podemos dar a la frmula. El polinomio de interpolacin para una tabla que contiene dos datos, es una lnea recta. La integral, corresponde al rea bajo la lnea recta en el intervalo , que es precisamente el rea del trapecio que se forma.

Ejemplo 1: Utilizar la regla del trapecio para aproximar la integral:

Solucin. Usamos la frmula directamente con los siguientes datos:

Por lo tanto tenemos que:

Ejemplo 2. Usar la regla del trapecio para aproximar la integral:

Solucin. Igual que en el ejemplo anterior, sustitumos los datos de manera directa en la frmula del trapecio. En este caso, tenemos los datos:

Por lo tanto, tenemos que:

La regla del trapecio se puede ampliar si subdividimos el intervalo subintervalos, todos de la misma longitud .

en

Sea

la particin que se forma al hacer dicha subdivisin. Usando

propiedades de la integral tenemos que:

Aplicando la regla del trapecio en cada una de las integrales, obtenemos:

Ahora bien, ya que todos los subintervalos tienen la misma longitud h, tenemos que:

Sustituyendo el valor de h y usando la notacin sigma, tenemos finalmente:

Esta es la regla del trapecio para n subintervalos. Obviamente, esperamos que entre ms subintervalos usemos, mejor sea la aproximacin a la integral.

DIAGRAMA DE FLUJO:
REGLA DEL TRAPECIO INICIO

Leer a, b, n

h=(b-a) n

s = f(a) f(b)

i = 1, n-1, 1

Xi = a + i*h

s = s + 2*f(xi)

AREA = S*h/2

Escrbir AREA

FIN

PROGRAMACION DEL METODO : GUIDE:

CODIFICACION:
function varargout = pushbutton1_Callback(h, eventdata, handles, varargin) f=inline(get(handles.edit1,'string')); a=str2double(get(handles.edit2,'string')); b=str2double(get(handles.edit3,'string')); n=str2double(get(handles.edit4,'string')); h=(b-a)/n; s=f(a)+f(b); for i=2:n x(i)=a+((i-1)*h); s=s+2*(f(x(i))); end AREA=s*(h/2);

set(handles.edit5,'string',AREA); % -------------------------------------------------------------------function varargout = pushbutton2_Callback(h, eventdata, handles, varargin) % $$$$====GRAFICA DE LA FUNCION====$$$$ f=inline(get(handles.edit1,'string')); ezplot(f);grid on % -------------------------------------------------------------------function varargout = pushbutton3_Callback(h, eventdata, handles, varargin) close(trapecio)

REGLA DE SIMPSON DE UN TERCIO


Suponemos que tenemos los datos:

donde

es el punto medio entre

En este caso se tiene que:

donde

es el polinomio de interpolacin para los datos en la tabla anterior.

Usaremos el polinomio de Lagrange. As, tenemos que:

Si denotamos

, entonces:

Simplificando trminos:

Vemos que cada uno de los trminos anteriores, es esencialmente de la misma forma, es decir, una constante por As, calculamos la siguiente integral por partes:

Sea:

por lo tanto,

Usamos esta frmula para calcular la integral de cada uno de los tres trminos de .

Debido al factor

se le conoce como la regla de Simpson de un tercio.

En la prctica, sustitumos el valor de final:

para obtener nuestra frmula

DIAGRAMA DE FLUJO:
INICIO

LEER F(x),a,b,n

h=b-a n

i=0,n,1

xi=a+h

n par S=0

i=2,n,1

S=S+F(xi-2)+4F(xi1)+F(xi)

I=S*h/3

ESCRIBIR I

FIN

PROGRAMACION DEL METODO: GUIDE:

CODIFICACION:
function varargout = pushbutton1_Callback(h, eventdata, handles, varargin) f=inline(get(handles.edit1,'string')); a=str2double(get(handles.edit2,'string')); b=str2double(get(handles.edit3,'string')); n=str2double(get(handles.edit4,'string')); h=(b-a)/n; for i=1:n+1 x(i)=a+(i-1)*h; end if rem(n,2)==0 s=0; for j=2:n

s=s+f(x(i-2))+4*f(x(i-1))+f(x(i)); end I=s*h/3 ; set(handles.edit5,'string',I) else end % -------------------------------------------------------------------function varargout = pushbutton2_Callback(h, eventdata, handles, varargin) f=inline(get(handles.edit1,'string')); a=str2double(get(handles.edit2,'string')); b=str2double(get(handles.edit3,'string')); ezplot(f,a,b), grid on %----------------------------------------------------------------------function varargout = pushbutton3_Callback(h, eventdata, handles, varargin)cc c close(sinpson13)

REGLA DE SIMPSON DE TRES OCTAVOS


Este caso corresponde a , es decir,

donde datos:

es un polinomio de interpolacin para los siguientes

Y donde , y partes iguales al intervalo

, .

son los puntos que dividen en tres

Igual que en el caso anterior, se usa el polinomio de interpolacin de Lagrange, y usando el mtodo de integracin por partes se llega a la siguiente frmula:

donde

. Debido al factor

es que se le di el nombre

de Regla de Simpson de 3/8. En la prctica, se sustituye el valor de h para obtener:

Ejemplo 1. Aproximar la siguiente integral, usando la regla de Simpson de :

Solucin. En este caso, tenemos los siguientes datos:

Los cuales sustitumos en la frmula, para obtener:

Al igual que en los dos casos anteriores, la regla de Simpson de 3/8, en intervalos se puede extender si subdividimos el intervalo de la misma longitud .

Sea la particin determinada de esta forma. Cada subintervalo lo dividimos en tres partes iguales, y sean y los puntos determinados as:

Aplicando la regla de

en cada uno de los intervalos tenemos:

Esta ltima, es la regla de Simpson de 3/8 para n subintervalos todos de la misma longitud.

DIAGRAMA DE FLUJO:
INICIO

S=0

LEER F(x),a,b,n

h=b-a n

n=3

i=3,n,3 ESCRIBI R n debe

S=S+3/8*h*[ F(xi-3)+3F(xi-2)+3F(xi-1)+F(xi)]

ESCRIBIR S

FIN

PROGRAMACION DEL METODO: GUIDE:

CODIFICACION:
function varargout = pushbutton1_Callback(h, eventdata, handles, varargin) f=inline(get(handles.edit1,'string')); a=str2double(get(handles.edit2,'string')); b=str2double(get(handles.edit3,'string')); ezplot(f,a,b), grid on % -------------------------------------------------------------------function varargout = pushbutton3_Callback(h, eventdata, handles, varargin) f=inline(get(handles.edit1,'string')); a=str2double(get(handles.edit2,'string')); b=str2double(get(handles.edit3,'string'));

n=str2double(get(handles.edit4,'string')); if rem(n,3)==0 h=(b-a)/n for i=1:1:n+1 x(i)=a+(i-1)*h end s=0 for j=1:3:n-1 s=s+f(x(j))+3*f(x(j+1))+3*f(x(j+2))+f(x(j+3)) end A=3*s*h/8 set(handles.edit5,'string',A) else set(handles.edit5,'string','n debe ser multiplo de 3') end

MTODO DE EULER
La idea del mtodo de Euler es muy sencilla y est basada en el significado geomtrico de la derivada de una funcin en un punto dado. Supongamos que tuviramos la curva solucin de la ecuacin diferencial y trazamos la recta tangente a la curva en el punto dado por la condicin inicial.

Debido a que la recta tangente aproxima a la curva en valores cercanos al punto de tangencia, podemos tomar el valor de la recta tangente en el punto como una aproximacin al valor deseado .

As, calculemos la ecuacin de la recta tangente a la curva solucin de la ecuacin diferencial dada en el punto . De los cursos de Geometra Analtica, sabemos que la ecuacin de la recta es:

donde m es la pendiente. En este caso, sabemos que la pendiente de la recta tangente se calcula con la derivada:

Por lo tanto, la ecuacin de la recta tangente es :

Ahora bien, suponemos que tanto estar dado como siguiente aproximacin:

es un punto cercano a , y por lo . De esta forma, tenemos la

De aqu, tenemos nuestra frmula de aproximacin:

Esta aproximacin puede ser suficientemente buena, si el valor de h es realmente pequeo, digamos de una dcima menos. Pero si el valor de h es ms grande, entonces podemos cometer mucho error al aplicar dicha frmula. Una forma de reducir el error y obtener de hecho un mtodo iterativo, es dividir la distancia en n partes iguales (procurando que estas partes sean de longitud suficientemente pequea) y obtener entonces la aproximacin en n pasos, aplicando la frmula anterior n veces de un paso a otro, con la nueva h igual a .

En una grfica, tenemos lo siguiente:

Ahora bien, sabemos que:

Para obtener nicamente hay que pensar que ahora el papel de lo toma el punto , y por lo tanto, si sustitumos los datos adecuadamente, obtendremos que:

De aqu se ve claramente que la frmula recursiva general, est dada por:

Esta es la conocida frmula de Euler que se usa para aproximar el valor de aplicndola sucesivamente desde hasta en pasos de longitud h.

DIAGRAMA DE FLUJO:

INICIO LEER F(x),a,b,n,y0

x0=a

h=b-a n

i=1,n,1

y1=y0+h0*f(x)

Y0=y1

x1=x0+h

x0=x1

ESCRIBIR y0

FIN

Programacin del metodo : GUIDE:

CODIFICACION:
function varargout = pushbutton1_Callback(h, eventdata, handles, varargin) funcion=get(handles.edit1,'string'); f=inline(funcion,'x','y'); x0=str2double(get(handles.edit2,'string')); x1=str2double(get(handles.edit3,'string')); n=str2double(get(handles.edit4,'string')); y0=str2double(get(handles.edit5,'string'));

h=(x1-x0)/n; X(1,1)=x0 Y(1,1)=y0 for i=1:n y1=y0+h*f(x0,y0); y0=y1; x1=x0+h; x0=x1; X(i+1,1)=x0; Y(i+1,1)=y0; end set(handles.edit6,'string',y1); set(handles.edit7,'string',X); set(handles.edit8,'string',Y); % -------------------------------------------------------------------function varargout = pushbutton2_Callback(h, eventdata, handles, varargin) X=str2num(get(handles.edit7,'string')); Y=str2num(get(handles.edit8,'string')); plot(X,Y,'.',X,Y,'r-'),grid on, axis equal % -------------------------------------------------------------------function varargout = pushbutton3_Callback(h, eventdata, handles, varargin) close(euler)

Metodo de Runge-Kutta de 4to orden


Los metodos desarrollados por Runge (1885), Kutta (1901), Heun (1900) y otros para la solucion de problemas con valor en la frontera. Este consiste en obtener un resultado que se obtendria al utilizar un numero finito de terminos de una serie de Taylor de la forma:

Este metodo es superior al metodo de punto medio (RungeKutta de segundo orden) ya que contiene los primeros cinco terminos de la serie de Taylor, lo cual significa gran exactitud sin el calculo de las derivadas, pero se tiene que evaluar la funcion f(x) cuatro veces para cada subintervalo.

Reacomodando para los valores de f(x) y haciendo f(x)' = y + hf(x), se tiene:

Las reglas o formulas de Runge-Kutta de orden cuatro para la ecuacion diferencial:

DIAGRAMA DE FLUJO:
INICIO

LEER F(x), X0,Y0,b, n

h=b-X0 n

i=1,n,1

K1=F( X0, Y0) K2=F(X0+h/2, Y0+h/2*K1) K3=F(X0+h/2, Y0+h/2*K2) K4=F(X0+h, Y0+h*K3)

Y1=Y0-h/6*(K1+2*K2+2*K3+K4)

X1=X0+h

X0=X1 Y0=Y1

ESCRIBIR Y0

FIN

PROGRAMACION DEL METODO: GUIDE:

CODIFICACION: function varargout = pushbutton1_Callback(h, eventdata, handles, varargin) f=inline(get(handles.edit1,'string')); a=str2double(get(handles.edit2,'string')); b=str2double(get(handles.edit3,'string')); ezplot(f,a,b), grid on % -------------------------------------------------------------------function varargout = pushbutton3_Callback(h, eventdata, handles, varargin) f1=get(handles.edit1,'string'); f=inline(f1,'x','y'); a=str2double(get(handles.edit2,'string')); b=str2double(get(handles.edit3,'string')); y0=str2double(get(handles.edit4,'string')); n=str2double(get(handles.edit5,'string')); h=(b-a)/n;

x0=a; for i=1:n k1=f(x0,y0); k2=f(x0+h/2,y0+(h/2)*k1); k3=f(x0+h/2,y0+(h/2)*k2); k4=f(x0+h,y0+h*k3); y1=y0+(h/6)*(k1+2*k2+2*k3+k4); x1=x0+h; x0=x1; y0=y1; end set(handles.edit6,'string',y1);