Procesos Numericos: 2011

martes, 20 de septiembre de 2011

Agradecimientos:

Queremos agradecerle a nuestro profesor Rafael David Rincon de Procesos numericos en la Unversidad EAFIT por brindarnos estos conocimientos y Julian Preciado, compañero que nos ayudo con la realizacion de los codigos de estos programas. A ellos muchas Gracias,

Jennifer Olano
Carolina Perez
Carlos H. Trujillo

Septimo Programa: Raices Multiples

RAICES MULTIPLES:

El Método de raíces múltiples es ampliamente utilizado para encontrar las raíces de la ecuación f(x)=0, ya que converge rápidamente, la contra es que uno debe conocer la derivada de f(x) y se necesita una aproximación inicial a la raíz.

Permite aproximar las primeras N iteraciones en el método de Newton-Raphson modificado aplicado a la función f tomando como aproximación inicial x0 . Observe que no requiere construir la función M definida en el método de Newton-Raphson modificado.

Codigo para Octave:

%METODO RAICES MULTIPLES

disp('METODO : NEWTON');

disp('por:');

disp('Carolina Perez Gaviria');

disp('Jennifer Olano Arrieta');

disp('Carlos Trujillo');

disp(' ');

fprintf ('Calculo de una raíz por el método de raíces mœltiples: ');

%fprintf me permite ingresar comentarios de manera textual que pueden orientar al usuario en el uso del programa, también permite mostrar el valor de las variables.

format long

%El comando format long me permite utilizar la máxima capacidad de almacenamiento de decimales permitidos por la máquina, de tal modo que el error por redondeo se disminuye, esto se explica al entender que tras cada iteración las cifras que se irán contaminando son las últimas. También pueden ser utilizados los comandos de formato simple o doble.

Xo=input('ingrese el valor inicial: ');

%El comando input me permite asignar a una variable un valor que ingresa el usuario. Xo, es uno de los valores iníciales que se ingresa para comenzar la búsqueda de raíces

Iter=input('ingrese el número de iteraciones: ');

Tol=input('ingrese la tolerancia que desea: ');

Fun=input('ingrese la funcion = ','s');

f=inline(Fun);

%Cuando ingreso función esta se encuentra en un formato simbólico, que no me sirve para utilizarla en el resto del programa, por esto se utiliza el formato inline, que la transforma y me permite evaluarla.

Y1=f (Xo);

%forma en la que evalúo la función en el valor inicial, y al mismo tiempo le asigno el nombre de Y

Du=input('ingrese la primera derivada = ','s');

Der=inline(Du);

%inline, permite asignar a una variable el valor de una función, para así utilizarla en el resto del programa

D=Der(Xo);

Du2=input ('ingrese la segunda derivada de la funcion = ','s');

Der2=inline (Du2);

D2=Der2 (Xo);

Error=Tol+1;

%como solo he calculado un valor de X, utilizo cualquier valor que sea mayor que la tolerancia que necesito, para que me continúe ejecutando el programa, pues cualquier valor que sea mayor que la tolerancia es inadecuado.

Cont=0;

% el contador hasta este momento está en cero, porque no se ha realizado ninguna operación

Denominador=D^2-(Y1*D2);

%Es necesario definir una variable solo para el denominador, pues se debe evaluar que este sea diferente de cero.

Z=[Cont,Xo,Y1,Error];

%Z, es una matriz en la que se almacenan los resultados de cada una de las iteraciones que realiza el programa.

while Y1~=0 & Error>Tol & Cont<Iter & Denominador~=0

%While es un comando que permite de manera repetitiva ejecutar un estamento mientras la condición sea verdadera.

%Operaciones que me ejecuta el método para llegar a la raíz

X1=Xo-((Y1*D)/(D^2-(Y1*D2)));

Y1=f(X1);

D=Der(X1);

D2=Der2(X1);

Error=abs((X1-Xo)/X1);

Cont=Cont+1;

Z(Cont,1)=Cont;

Z(Cont,2)=Xo;

Z(Cont,3)=Y1;

Z(Cont,4)=D;

Z(Cont,5)=D2;

Z(Cont,6)=Error;

Xo=X1;

end

%Evalúo las condiciones de éxito y de fracaso, utilizando el comando if

if Y1==0

fprintf('X1 es raíz: ');

else

if Error<Tol

fprintf('La raíz es %g con un error de %g: ',X1,Error);

else

if Denominador==0

fprintf('Se está haciendo división por cero')

else

fprintf('Se llego al máximo de Iteraciones: ');

end

Sexto Programa: Metodo de la Secante

METODO DE LA SECANTE:

El método de la secante es un método que permite evaluar las raíces de funciones cuya derivada es difícil de calcular. En dichos casos, la derivada se puede aproximar mediante una diferencia finita dividida hacia atrás. Y se obtiene de este modo la siguiente fórmula iterativa.

Codigo para Octave:

%SECANTE

disp('METODO : SECANTE');

disp('por:');

disp('Carolina Perez Gaviria');

disp('Jennifer Olano Arrieta');

disp('Carlos Trujillo');

disp(' ');

format long

Xo=input('INDIQUE EL VALOR DONDE DESEA QUE COMIENCE LA BUSQUEDA DE RAICES: ');

X1=input('INGRESE EL SEGUNDO VALOR DONDE TERMINA LA BUSQUEDA DE RAICES: ');

TOL=input('INGRESE LA TOLERANCIA QUE USTED DESEA: ');

ITER=input('CANTIDAD MAXIMA DE ITERACIONES: ');

Fun=input('COLOQUE LA FUNCION ENTRE COMILLAS EN LA CUAL SE BUSCARA LA RAIZ = ','s');

F=inline (Fun);

Yo=F(Xo)

Y1=F(X1)

if Yo==0

fprintf('Xo ES RAIZ DE ESTA FUNCION: ');

else

DEN=y1-yo;

%DEN se utiliza para indicar el denominador

E=TOL+1;

cont=0;

T= [Xo, X1, Y1, E];

%T, es la matriz en la que se almacenan los resultados de cada una de las iteraciones que realiza el programa para ser finalmente entregados en una tabla.

while Y1~=0 & E>TOL& cont<ITER & DEN~=0

%While es el que permite que de manera repetitiva se ejecute mientras las condiciones sean verdaderas.

X2=X1-((Y1*(X1-Xo))/(Y1-Yo));

Y2=F(X2);

E=abs((X2-X1)/X2);

cont=cont+1;

Xo=X1;

Yo=Y1;

X1=X2;

Y1=Y2;

DEN=Y1-Yo;

T(cont,1)=cont;

T(cont,2)=Xo;

T(cont,3)=X1;

T(cont,4)=Y1;

T(cont,5)=E;

end

if Y1==0

fprintf('X1 es raiz: ');

else

if E<TOL

fprintf('X1 ES RAIZ CON UN VALOR DE %g y un error de %g : ',X1,E);

else

if DEN==0

fprintf('DENOMINADOR ES CERO : ');

else

fprintf('NUMERO MENOR DE ITERACIONES: ');

end

fprintf('interaciones Xo X1 Y1 Error relativo: ');

disp(T);

Quinto Programa: Newton - Raphson

MÉTODO DE NEWTON-RAPHSON:

Una de las formas más utilizadas para encontrar raíces es la fórmula de Newton-Raphson. Si el valor inicial para la raíz es xi, entonces se puede trazar una tangente desde el punto [xi, f(xi)] de la curva. Por lo común el punto donde esta tangente cruza al eje x representa una aproximación mejorada de la raíz.

Codigo para Octave:

%Metodo de Newton

format long

Xo=input ('coloque el valor inicial: ');

Iter=input ('cantidad de iteraciones: ');

Tol=input ('indique la tolerancia deseada: ');

Fun=input ('ingrese la funci—n = ','s');

Der=input ('ingrese la derivada de la funcion = ','s');

f=inline (Fun);

Y1=f (Xo);

Der=inline (Du);

D=Der (Xo);

% Evalua la derivada en Xo para poder saber si es adecuad para seguir con este mŽtodo, es decir que sea diferente de cero

Error=Tol+1;

%Ya que solo calcule un valor de x, debemos utilizar un valor mayor a la tolerancia.

Cont=0;

% el contador se encuentra en cero ya que no se ha realizado ninguna operaci—n.

Z= [Cont, Xo, Y1, Error];

%Z, es la matriz en la que se almacenan los resultados de cada una de las iteraciones que realiza el programa para ser finalmente entregados en una tabla.

while Y1~=0 & Error>Tol & Cont<Iter&D~=0

%while, comando que permite ejecutar el programa mientras se cumplan ciertas condiciones.

X1=Xo-(Y1/D);

Y1=f(X1);

D=Der (X1);

Error=abs((X1-Xo)/X1);

Cont=Cont+1;

Z(Cont,1)=Cont;

Z(Cont,2)=Xo;

Z(Cont,3)=Y1;

Z(Cont,4)=D;

Z(Cont,5)=Error;

Xo=X1;

end

if Y1==0

fprintf('X1 es raíz\n');

else

if Error<Tol

fprintf('La raíz es %g con un error de %g\n',X1,Error);

else

if D==0

fprintf('Se esta dividiendo por cero')

else

fprintf('numero m‡ximo de iteraciones\n');

end

fprintf(' Xo, X1, Y1, Error\n');

disp(Z);

Cuarto Pograma: Punto Fijo

PUNTO FIJO:

El método de punto fijo se aplica para ecuaciones de la forma x = g(x). Se parte de un punto inicial x0 y se aplica la fórmula xn+1 = g(xn) para n ¸ 0 en caso de que exista limn!1xn = p, si g es continua en este valor p se tiene que: p = limn!1xn = limn!1g(xn−1) = g(limn!1xn−1) = g(p) donde p sería la solución buscada.

Codigo para Octave:

%Metodo De Punto Fijo

disp('METODO : DE : PUNTO : FIJO');

disp('por:');

disp('Carolina Perez Gaviria');

disp('Jennifer Olano Arrieta');

disp('Carlos Trujillo');

disp(' ');

format long

Xo=input('ingrese el valor inicial: ');

Iter=input('ingrese el numero de iteraciones: ');

Tol=input('ingrese la tolerancia deseada: ');

Fun=input('Indique la funci—n entre comillas: ');

G=input('ingrese la funcion despejada entre comillas = ','s');

f=inline(Fun);

g=inline(G);

Y1=f(Xo);

if Y1==0

fprintf('Xo es raiz: ');

else

Error=Tol+1;

Cont=0;

A=[Cont,Xo,Y1,Error];

while Y1~=0 & Error>Tol & Cont<Iter

X1=g(Xo);

Y1=f(X1);

Error=abs((X1-Xo)/X1);

Cont=Cont+1;

A(Cont,1)=Cont;

A(Cont,2)=Xo;

A(Cont,3)=X1;

A(Cont,4)=Y1;

A(Cont,5)=Error;

Xo=X1;

end

if Y1==0

fprintf('X1 es raiz: ');

else

if Error<Tol

fprintf('La raiz es %g con un error de %g: ',X1,Error);

else

fprintf('numero maximo de Iteraciones: ');

end

fprintf(' Xo, X1, Y1, Error: ')

disp(A)

end

Tercer Programa: Regla Falsa

REGLA FALSA:

Otro método que comúnmente se emplea es el de Regula Falsa. Este método también tiene otras denominaciones, como son: Regla falsa, Posición falsa o Interpolación Lineal. Su nombre original que está en latín, denota su antigüedad. La idea del método es bastante similar al del método de bisección. Requiere un intervalo que cumpla los mismos supuestos que el método de Bisección. En lugar de obtener el punto medio en cada iteración, el método busca reemplazar la función original por otra a la cual sea más simple localizar su raíz. Dado que comenzamos con solo un intervalo, es decir, sólo tenemos 2 puntos, buscamos la curva más simple que pase por estos 2 puntos. Lógicamente usamos una línea recta. Entonces en vez de obtener puntos medios en este método se halla las raíces de las rectas que pasen por

los puntos que determinen nuestros intervalos.

Codigo para Octave:

%Metodo de la Regla Falsa

disp('METODO : REGLA FALSA');

disp('por:');

disp('Carolina Perez Gaviria');

disp('Jennifer Olano Arrieta');

disp('Carlos Trujillo');

disp(' ');

format long;

Xi=input('Cual es el valor de Xi: ');

Xu=input('Cual es el valor de Xu: ');

tol=input('Ingrese la tolerancia: ');

Ite=input('Cantidad de iteraciones: ');

Fun=input('ingrese la ecuacion entre comillas = ','S');

f=inline(Fun);

Yi=f(Xi);

Yu=f(Xu);

if Yi==0

fprintf('Xi es raiz: ');

else

if Yu==0

fprintf('Xu es raiz: ');

else

if Yi*Yu>0

fprintf('No existe raiz: ');

else

Xm=(Xu)-((f(Xu)*(Xi-Xu))/(f(Xi)-f(Xu)));

Ym=f(Xm);

Error=tol+1;

Cont=1;

M=[Cont,Xi,Xu,Xm,Ym,Error];

while Ym~=0 & Error>tol & Cont<Ite %expresion

auxiliar=Xm; %orden

if Yi*Ym<0

Xu=Xm;

Yu=Ym;

else

Xi=Xm;

Yi=Ym;

end

Xm=(Xu)-((f(Xu)*(Xi-Xu))/(f(Xi)-f(Xu)));

Ym=f(Xm);

Error=abs(Xm-auxiliar);

Cont=Cont+1;

M(Cont,1)=Cont;

M(Cont,2)=Xi;

M(Cont,3)=Xu;

M(Cont,4)=Xm;

M(Cont,5)=Ym;

M(Cont,6)=Error;

end

if Ym==0

fprintf('Xm es raiZ: ');

else

if Error<tol

fprintf('Xm es raiz y tiene un valor de %g con un error de %g: ',Xm,Error),

else

fprintf('No hay soluci—n en las iteraciones dadas: ');

end

fprintf(' xi Xu Xm Ym Error: ')

disp(M);

end

Segundo Programa: Biseccion

BISECCION:

El método de bisección, conocido también como de corte binario, de partición de intervalos o de Bolzano, es un tipo de búsqueda incremental en el que el intervalo se divide siempre a la mitad. Si la función cambia de signo sobre el intervalo, se evalúa el valor de la función en el punto medio.La posición de la raíz se determina situándola en el punto medio del subintervalo,

Dentro del cual ocurre un cambio de signo. El proceso se repite hasta obtener una mejor aproximación. Para el método de bisección tenemos el siguiente código realizado en Octave y compatible con Matlab.

Codigo para Octave:

%Biseccion

disp('METODO : BISECCION');

disp('por:');

disp('Carolina Perez Gaviria');

disp('Jennifer Olano Arrieta');

disp('Carlos Trujillo');

disp(' ');

format long

Xo=input ('Colocar el primer numero del intervalo: ');

X1=input ('Colocar el segundo numero del intervalo: ');

Tol=input ('Indicar la tolerancia: ');

Iter=input ('Cantidad de iteraciones que desea: ');

Fun=input ('Indique la funcion entre comillas = ','s');

F=inline (Fun);

Yo=F(Xo);

Y1=F(X1);

if Yo==0

fprintf('Xo es raiz: ');

else

if Y1==0

fprintf('X1 es raiz');

else

if Yo*Y1>0

fprintf('No existe raiz: ');

else

Xm=(Xo+X1)/2;

Ym=F(Xm);

Error=Tol+1;

Cont=1;

T=[Cont,Xo,X1,Xm,Ym,Error];

while Ym~=0 & Error>Tol & Cont<Iter

Auxiliar=Xm;

%Auxiliar se utiliza para guardas un valor que luego se va a utilizar.

if Yo*Ym<0

X1=Xm;

Y1=Ym;

else

Xo=Xm;

Yo=Ym;

end

Xm=(Xo+X1)/2;

Ym=F(Xm);

Error=abs(Xm-Auxiliar);

Cont=Cont+1;

T(Cont,1)=Cont;

T(Cont,2)=Xo;

T(Cont,3)=X1;

T(Cont,4)=Xm;

T(Cont,5)=Ym;

T(Cont,6)=Error;

end

if Ym==0

fprintf('Xm es raiz: ');

else

if Error<Tol

fprintf( 'Xm raíz=%g con error de %g : ',Xm,Error);

else

fprintf('No hay raiz: ');

end

fprintf('Iteraciones Xo X1 Xm Ym Error: ');

disp(T);

end