Algoritmos para El Método de La Regla Falsa en MatLab1.0

Algoritmo para el método de la Regla Falsa en MatLab.
 Código 1
function [tabla, XR, ER, iteracion] = reglaFalsa(f, limInf, limSup,
numIter)
% INPUT:
% f = función
% limInf = Límite inferior.
% limSup = Límite superior.
% numIter = Número de iteraciones.
% OUTPUT:
% M = Tabla de resultados
% XR = Ultima iteración de la raíz de la función.
% ER = Ultima iteracion del error relativo.
% Iteracion = Número de iteraciones
fxa = f(limInf);
fxb = f(limSup);
%Condicion para evaluar si existe una raiz en el intervalo
if fxa * fxb > 0
msjerror('No existe una raíz en el intervalo indicado!');
end
for i = 1:numIter - 1
xr(i) = limSup(i) - fxb(i) * ((limSup(i) - limInf(i)) / (fxb(i) -
fxa(i))); %Punto medio actual.
fxr(i) = f(xr(i)); %Evalua en el punto medio actual.
if f(xr(i)) * f(limInf(i)) > 0 %Si esta condición se cumple, la raíz
no existe en el limInf y xr
limInf(i+1) = xr(i); %xr es el nuevo límite inferior.
limSup(i+1) = limSup(i); %El valor de limSup se mantiene.
fxa(i+1) = f(limInf(i+1));
fxb(i+1) = f(limSup(i+1));
elseif f(xr(i)) * f(limSup(i)) > 0 %Si esta condición se cumple, la
raíz no existe en xr y limSup
limInf(i+1) = xr(i); %xr es el nuevo límite superior.
limSup(i+1) = limInf(i); %El valor de limInf se mantiene igual.
fxa(i+1) = f(limInf(i+1));
fxb(i+1) = f(limSup(i+1));
end
try
xr(i+1)=limSup(i+1)-fxb(i+1)*((limSup(i+1)-limInf(i+1))/(fxb(i+1)-
fxa(i+1))); %Actulizamos el valor de xr
catch
error('Demasiadas iteraciones');
end
fxr(i+1)=f(xr(i+1));
error(i+1)=abs((xr(i+1)-xr(i))/xr(i+1))*100; %Calcula el error
relativo actual
end
%Mostrar tabla
encabezado = {'limInf', 'xr', 'limSup', 'f(a)', 'f(xr)', 'f(b)', 'Error
relativo (%)'};
cuerpo = num2cell([limInf', xr', limSup', fxa', fxr', fxb', error']);
tabla = [encabezado; cuerpo];
XR = xr(end);
ER = error(end);
iteracion = i+1;
%Mostrar resultados
resultado = f(XR);
disp(['Funcion: ' func2str(f) ' con un valor de: ' num2str(XR) ', el
resultado es: ' num2str(resultado)]);
disp(['Error relativo (%): ' num2str(ER)]);
disp(['Número de iteraciones: ' num2str(iteracion)]);
Para evaluar la función:

[tabla,XR,ER,iteracion] = reglaFalsa(@(x) ((1/(exp(x)))+(3*x)),-2,-1,10)
 Código 2
function [M, XR, ER, Iter] = ReglaFalsaFcn(f, xl, xu, Niter, Tol)
%Autor: Rolando Valdez Guzmán
%Alias: Tutoingeniero
%Canal de Youtube: https://www.youtube.com/channel/UCU1pdvVscOdtLpRQBp-
TbWg
%Versión: 2.0
%Actualizado: 30/jul/2020
%Método de la regla falsa modificada (versión función) ESPAÑOL.

%Llama a esta función desde la ventana de comandos o cualquier script
para
%encontrar la raíz de una función en un intervalo y obtén una tabla con
el
%proceso.
% ESTA FUNCION PIDE LOS SIGUIENTES DATOS DE ENTRADA:
% f = función como un identificador de función (function handle)

% ej. @(x) cos(x)
% xl = Límite inferior. Este dato es un escalar.
% xu = Límite superior. Este dato es un escalar.
% Niter = Número de iteraciones.
% Tol = Tolerancia para el criterio de convergencia a superar o igualar
en
% porcentaje.
% VARIABLES DE SALIDA:
% M = Tabla de resultados {'xl', 'xr', 'xu', 'f(xl)', 'f(xr)', 'f(xu)',

'Error relativo (%)'}
% XR = Ultima iteración de la raíz de la función.
% ER = Ultima iteracion del error relativo.
% Iter = Número de iteraciones
%METODOS DE SOLUCION
%Método 1: Si Niter está vacío (Niter = []) entonces se debe especificar
un
%error relativo mínimo para converger.
%Método 2: Si Tol está vacío (Tol = []) entonces se debe especificar un
%número máximo de iteraciones para el código. Es posible que un número
muy
%grande de iteraciones cree un error y un mensaje aparecerá sugiriendo
%reducir el número de iteraciones.
%Si se ingresan menos de tres datos de entrada...

if nargin < 5
error('Se necesita definir una función, un intervalo a evaluar, un
número máximo de iteraciones y un error relativo mínimo');
%Si se ingresan todos los datos de entrada, elegir un método de solución
else
if isempty(Niter) == 1
metodo = 1;
Niter = 1000;
disp(newline);
disp('Solución por error relativo mínimo para converger');
elseif isempty(Tol) == 1
metodo = 2;
disp(newline);
disp('Solución por número máximo de iteraciones para converger');
elseif isempty(Niter) == 0 && isempty(Tol) == 0
error('Niter y Tol no pueden tener un dato de entrada al mismo
tiempo, uno de los dos debe estar vacío (ejemplo: Niter = [])');
end
end
fxl = f(xl); %Punto en Y para el límite inferior.

fxu = f(xu); %Punto en Y para el límite superior.
il = 0;
iu = 0;
if fxl * fxu > 0 %Esta propiedad es la que hace que éste sea un método
cerrado.
error('No hay una raíz en ese intervalo!');
end
for i = 1:Niter - 1
xr(i) = xu(i) - fxu(i) * ((xu(i) - xl(i)) / (fxu(i) - fxl(i)));
%Calcula el punto medio falso actual.
fxr(i) = f(xr(i)); %Evalua la función en el punto medio falso actual.
if f(xr(i)) * f(xl(i)) > 0 %Si esta condición se cumple, la raíz NO

está entre xl y xr
xl(i+1) = xr(i); %El punto medio es el nuevo límite inferior.
xu(i+1) = xu(i); %El límite superior se mantiene igual.
fxl(i+1) = f(xl(i+1));
fxu(i+1) = f(xu(i+1));
il = 0;
iu = iu + 1;
%Si usamos dos o más veces seguidas el mismo límite superior,
evaluar en la función y dividir sobre 2
if iu >= 2
fxu(i+1) = (fxu(i))/2;
end
elseif f(xr(i)) * f(xu(i)) > 0 %Si esta condición se cumple, la raíz
NO está entre xl y xr
xu(i+1) = xr(i); %El punto medio es el nuevo límite superior.
xl(i+1) = xl(i); %El límite inferior se mantiene igual.
fxl(i+1) = f(xl(i+1));
fxu(i+1) = f(xu(i+1));
iu = 0;
il = il + 1;
%Si usamos dos o más veces seguidas el mismo límite inferior,
evaluar en la función y dividir sobre 2
if il >= 2
fxl(i+1) = (fxl(i))/2;
end
end
%Asegurarse de que si Niter es muy grande aparezca una alerta.
try
xr(i+1)=xu(i+1)-fxu(i+1)*((xu(i+1)-xl(i+1))/(fxu(i+1)-fxl(i+1)));
%Actulizamos el punto medio falso y su punto en Y
catch
error('Intenta un número menor de iteraciones');
end
fxr(i+1) = f(xr(i+1));
Error(i+1) = abs((xr(i+1) - xr(i)) / xr(i+1)) * 100; %Calcula el
error relativo actual
if Error(i+1) < Tol %Si el error relativo es menor a la tolerancia

exigida, se acaba el ciclo.
break;
end
end
M1 = {'xl', 'xr', 'xu', 'f(xl)', 'f(xr)', 'f(xu)', 'Error relativo (%)'};

M2 = num2cell([xl', xr', xu', fxl', fxr', fxu', Error']);
M = [M1; M2];
XR = xr(end);
ER = Error(end);
Iter = i+1;
%Evaluar la función con la raíz aproximada y mensaje de resumen.

Resultado = f(XR);
disp(['Evaluando la función ' func2str(f) ' con ' num2str(XR) ', el
resultado es: ' num2str(Resultado)]);
disp(['Error relativo (%): ' num2str(ER)]);
disp(['Número de iteraciones: ' num2str(Iter)]);
Para evaluar
[M, XR, ER, Iter] = ReglaFalsaFcn(@(x)((1/(exp(x)))+(3*x)), -2, -1, [], 0.001)
 Código 3
 function y=falsap(fun, an,bn,tol)
 u=subs(fun,an);
 v=subs(fun,bn);
 a=an;
 b=bn;
 while abs(u)>tol
 p=a-u*(b-a)/(v-u);
 w=subs(fun,p);
 if u*v<0;
 a=an;
 b=p;
 else
 a=p;
 b=bn;
 end
 u=subs(fun,a);
 v=subs(fun,b);
 end
 p
Para evaluar
y=falsap (@(x)((1/(exp(x)))+(3*x)), , -1,-2,0.001)

Algoritmos para El Método de La Regla Falsa en MatLab1.0

Cargado por

Copyright:

Formatos disponibles

Algoritmos para El Método de La Regla Falsa en MatLab1.0

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Algoritmos para El Método de La Regla Falsa en MatLab1.0

Cargado por

Copyright:

Formatos disponibles

Algoritmo para el método de la Regla Falsa en MatLab.

Para evaluar la función:

%Método de la regla falsa modificada (versión función) ESPAÑOL.

% ESTA FUNCION PIDE LOS SIGUIENTES DATOS DE ENTRADA:

% f = función como un identificador de función (function handle)

% M = Tabla de resultados {'xl', 'xr', 'xu', 'f(xl)', 'f(xr)', 'f(xu)',

%Si se ingresan menos de tres datos de entrada...

fxl = f(xl); %Punto en Y para el límite inferior.

if f(xr(i)) * f(xl(i)) > 0 %Si esta condición se cumple, la raíz NO

if Error(i+1) < Tol %Si el error relativo es menor a la tolerancia

M1 = {'xl', 'xr', 'xu', 'f(xl)', 'f(xr)', 'f(xu)', 'Error relativo (%)'};

%Evaluar la función con la raíz aproximada y mensaje de resumen.

y=falsap (@(x)((1/(exp(x)))+(3*x)), , -1,-2,0.001)

También podría gustarte