Trabajo Final

Métodos Numéricos
Mtro. Juan Soufflé Hernández
Ing. En Mecatrónica
Campos Valenzuela Sofía Alejandra
16330786

Hermosillo, Sonora. Diciembre de 2017

Unidad I

Método de Taylor
Sea y(t) una función tal que sea N veces continuamente diferenciable en el intervalo [a,b]
y existe y(N+1) existe en [a, b] Para todo tk + h ∈ [a, b] habrá un número ξ(tk) ∈[t k +h, b]
tal que:
y(tk+h)=y(tk)+y'(tk)h+y''(tk) h^2/2! + …+y(N)(tk) h^N/hN! +y^(N+1)(ξ(tk)) h^N+1/N+1!

clear all
clc
syms x
fun=input('f(x): ');
f = inline(fun);
x1 = input('X(i): ');
x2 = input('X(i+1): ');
n = input('Número de Orden: ');
h = abs(x2 - x1);
v1 = f(x1);
v2 = f(x2);
et = abs((v2 - v1)/v2 * 100);
X(1,:) = [0 v1 0 et];
for i=1:n
X(i+1,1) = i;

D = diff(fun,i);
d1=inline(D);
 d=d1(x1);
v1= v1+(d*((h^i)/factorial(i)));
X(i+1,2) = v1;

et=abs(((v2-v1)/v2)*100);
X(i+1,4) = et;

ea = abs((X(i+1,2)-X(i,2))/X(i,2)*100);
X(i+1,3) = ea;

if ea <=10^(-1)
break
end
end

Unidad II

Bisección
Este método consiste en obtener una mejor aproximación de la raíz a partir de un
intervalo inicial (a,b) en el cual hay un cambio de signo en la función, es decir: f(a)f(b)<0.
Se obtiene el punto medio:
clear all
format short;
a=input('Introduzca el valor de a: ');
b=input('Introduzca el valor de b: ');
cont=input('Introduzca el número de iteraciones cont: ');
fun=input('Introduzcal a funcion f(x)=','s');
f=inline(fun);
for k=1:cont
c=(a+b)/2;
e=abs((b-a)/2);
A(k,:)=[k a b c f(c) e];
if f(a)*f(c)<0
b=c;
else
a=c;
end
end
fprintf('\n \tk \ta \tb \tc \tf(c) \terror \n')
disp(A)
fprintf('Solución:\n c=%8.5f\n',c)
fprintf('f(c)=%8.5f\n',f(c))
fprintf('error=%8.5f\n',e)

Falsa posición
El método de la falsa posición pretende conjugar la seguridad del método de la bisección
con la rapidez del método de la secante. Este método, como en el método de la bisección,
parte de dos puntos que rodean a la raíz f(x) = 0, es decir, dos puntos x0 y x1tales que
f(x0)f(x1) < 0. La siguiente aproximación, x2, se calcula como la intersección con el eje X
de la recta que une ambos puntos (empleando la ecuación (35) del método de la secante).

function [xr]=pfalse(y)
%función para calcular la raíz de una ecuación
%mediante el método de posición falsa

%Análisis gráfico de la ecuación

xl=input('Ingrese el límite inferior para graficar: ');
xu=input('Ingrese el límite superior para graficar: ');
t=linspace(xl,xu,800);
plot(t,subs(y,t))
grid on
xl=input('Ingrese el límite inferior: ');
xu=input('Ingrese el límite superior: ');
error=100;
xr=0;
while error>0.0000001
aux=xr;
xr=xu-((subs(y,xu)*(xl-xu))/(subs(y,xl)-subs(y,xu)));
h=subs(y,xl)*subs(y,xu);
if (h<0) %sentencias condicionales para definir los nuevos
límites.
xu=xr;
elseif(h>0)
cl=xr;
else
error=0.0000001; %en caso de que h=0 se terminan las iteraciones
end
error=((xr-aux)/xr)*100; %se calcula el error relativo aproximado
end
end

Punto fijo
El Método de Punto Fijo (también conocido como iteración de punto fijo), es otro método
para hallar los ceros de f(x). Para resolver f(x) = 0, se reordena en una forma equivalente:
f(x) = 0, x - g(x) = 0, x = g(x). Observe que si c es un cero de f(x), f(c)=0 y c=g(c). (Siempre
que se tenga c=g(c) se dice que c es un punto fijo de la función g). Para aproximar un
cero de f se utiliza la iteración de punto fijo (1) xn+1 = g(xn) , n = 0, 1, 2, 3, . . . donde x0
es una aproximación inicial del cero de f.
xf(1)=input('Ingrese el valor inicial: ');
tol=input('Ingrese el porcentaje de error: ');
syms x;
f=input('Ingrese la función f(x), despejada g(f(x)): ');

i=1;
ea(1)=100;
while abs(ea(i))>=tol,
xf(i+1)=subs(f,x,xf(i));
ea(i+1)=abs((xf(i+1)-xf(i))/xf(i+1))*100;
i=i+1;
end
fprintf('i xf(i) Error aprox (i) \n');
for j=1:i;
fprintf('%2d \t %11.7f \t %7.3f \n',j-1,xf(j),ea(j));
end

Newton--Raphson
Este método es uno de los más utilizados para localizar raíces ya que en general es muy
eficiente y siempre converge para una función polinomial. Se requiere que las funciones
sean diferenciables, y por tanto, continuas, para poder aplicar este método. Se debe partir
de un valor inicial para la raíz: xi , este puede ser cualquier valor, el método convergirá a
la raíz más cercana.

%graficamos la función en un intervalo

sup=input('Ingrese el límite superior para graficar: ');
in=input('Ingrese el límite inferior para visualización: ');
t=linspace(in,sup,500); %generamos un vector con los valores
plot(t,subs(Y,t)) %generamos la gráfica
grid on

Xn=input('Ingrese el valor aproximado de la raíz: '); %se solicita

la estimación inicial
Ydx = diff(Y,x); %derivamos la función Y con respecto a X y lo
asignamos a la variable Ydx

%inicializar variables
error=!;
tolerancia=0.0001;

while error>=tolerancia %condición de terminación cuando el error

sea menor a la tolerancia

X1=Xn-(subs(y,Xn)/subs(Ydx,Xn)); %formula de Newton-Rahpson

error=(X1-Xn)/X1; %cálculo del error
Xn=X1; %asignación del nuevo valor de Xn para la siguiente
iteración
end
end

Secante
El método de la secante parte de dos puntos (y no sólo uno como el método de Newton) y
estima la tangente (es decir, la pendiente de la recta) por una aproximación de acuerdo
con la expresión:

Sustituyendo esta expresión en la ecuación del método de Newton, obtenemos la

expresión del método de la secante que nos proporciona el siguiente punto de iteración:

function [Xa] =Secante()

syms x
y=input('Ingrese la función: ');
% espacio opcional en el que hacemos una previsualización
sup = input('Ingrese el límite superior para ver la gráfica : ');
infe = input('Ingrese el límite inferior para la visualización:
');
t=linspace(infe,sup,700);
plot(t,subs(y,t))
grid on
clc

% continuamos con el método y pedimos dos valores iniciales, para

x0 y x1
x0=input('Ingrese un valor para x0: ');
x1=input('Ingrese un valor para x1: ');

error=100;
tolerancia=0.00001;

while error>tolerancia
xa=x1-((subs(y,x1)*(x0-x1))/(subs(y,x0)-subs(y,x1)))
error=abs((xa-x1)/xa);
x0=x1;
x1=xa;
end
end

Unidad III

Eliminación Gaussiana
En forma general este método propone la eliminación progresiva de variables en el
sistema de ecuaciones, hasta tener sólo una ecuación con una incógnita. Una vez
resuelta esta, se procede por sustitución regresiva hasta obtener los valores de todas las
variables.

%
% Script 4 para el algoritmo de la
% eliminacion gaussiana
%
for k=1:n-1, % numero de pasos
v(k+1:n) = A(k+1:n,k)/A(k,k); %calculamos los multiplicadores
 v = v(:); %nos interesa el vector columna
% actualizamos la parte activa
A(k+1:n,k+1:n) = A(k+1:n,k+1:n)- v(k+1:n)*A(k,k+1:n);
end

Gauss-Jordan
Este método, que constituye una variación del método de eliminación de Gauss, permite
resolver hasta 15 o 20 ecuaciones simultáneas, con 8 o 10 dígitos significativos en las
operaciones aritméticas de la computadora. Este procedimiento se distingue del método
Gaussiano en que cuando se elimina una incógnita, se elimina de todas las ecuaciones
restantes, es decir, las que preceden a la ecuación pivote así como de las que la siguen.
%método de Gauss-Jordan(con procedimiento)
%en el siguiente programa se puede determinar la solución de una
matriz nxn
%si en la matriz 2 se especifican los coeficientes o se puede
determinar la
%inversa de una matriz si a la matriz 2 se le asigna el valor de
la matriz
%identidad . La idea de este programa es ir realizando el
procedimiento
%paso a paso para finalmente llegar a la respuesta
%ejemplo1: A=[1 2 3; 4 5 6; 7 8 9] y B=[3 4 5]'
%ejemplo2: A=[1 2 3; 4 5 6; 7 8 9] y B=eye(3)
%para solo llegar a la respuesta en el ejemplo 1 se puede ingresar
A\B y
%para el ejemplo 2 se ingresa inv(A)
A=input('ingrese la matriz 1 '); %% entrada de
B=input('ingrese la matriz 2 '); % datos %%
C=[A B]; %%unión de los datos en una solo matriz
for i=1:length(C(:,1)) %%para i desde la primera fila hasta el
número de filas existentes
if C(i,i)~=1 %%si el elemento i,i de la diagonal es diferente de 1
C(i,:)= C(i,:)./C(i,i); %entonces se convierte a 1
dividiendo toda la fila por dicho elemento
disp(C) %salida de datos
end
%además el resto de elementos de la columna deben convertirse a 0
:
%es decir si n es diferente de i ya que si i y n son iguales
entonces el
%elemento se encuentra en la diagonal
for n=1:length(C(:,1)) %para n desde la primera fila hasta el
número de filas existentes
if n~=i % si n en la columna i no está en la diagonal es
decir si i no es igual a n
C(n,:)=-C(n,i).*C(i,:)+C(n,:); %entonces se convierte a
0
disp(C)
end
end
end

Descomposición LU
El método de descomposición LU para la solución de sistemas de ecuaciones lineales
debe su nombre a que se basa en la descomposición de la matriz original de coeficientes
(A) en el producto de dos matrices (L y U). Esto es: A = LU, donde:
L - Matriz triangular inferior
U - Matriz triangular superior con todos los elementos de la diagonal principal iguales a 1.

function [l,u]=LUdoolitle(a)

n=length(a);
l=a*0; u=a*0;
for k=1:n
u(k,k:n)=a(k,k:n)-l(k,1:k-1)*u(1:k-1,k:n);
l(k,k)=1;
l(k+1:n,k)=(a(k+1:n,k)-l(k+1:n,1:k-1)*u(1:k-1,k))/u(k,k);
end

Gauss-Seidel
El método de Gauss-Seidel es el más comúnmente usado para resolver sistemas muy
grandes de ecuaciones lineales. Es una modificación del método de Jácobi que hace que
la convergencia sea más rápida. Comienza con una aproximación inicial x(0) a la solución
x y genera una sucesión de vectores x(k) que convergen a la solución x.
function
[sol,niteraciones,error]=metodo_gauss_seidel(A,B,x0,cotaerror)
D=diag(diag(A));
U=triu(A)-D;
L=tril(A)-D;
M=-inv(D+L)*U;
N=inv(D+L)*B;
cont=1;
xant=x0;
xsig=M*xant+N;
while norm(xsig-xant,inf)>cotaerror
cont=cont+1;
xant=xsig;
xsig=M*xant+N;
end
sol=xsig;
niteraciones=cont;
error=norm(xsig-xant,inf);
end

Unidad IV

Interpolación lineal y cuadrática

Se le llama polinomio interpolador correspondiente a esos puntos. Una vez obtenida su
expresión dando valores en él se pueden encontrar nuevos puntos de la función. Los
resultados obtenidos son naturalmente estimaciones aproximadas. La interpolación se
dirá lineal cuando sólo se tomen dos puntos y cuadrática cuando se tomen tres.
n=9;
syms x;
xn=[-5 -3 -2 -1 0 1 2 3 4 5];
yn=1./(1.+xn.^2);
plot(xn,yn,'*r')
hold on
p=0;
for i=1:n
L=1;
for j=1:n
if j~=i
L=L*(x-xn(j))/(xn(i)-xn(j));
end
end
p=p+L*yn(i);
end
p=simplify(p)
pretty(p)
x=-5:0.01:5;
f=1./(1+x.^2);
plot(x,f);
end

Polinomio de Lagrange

La interpolación de polinomios de Lagrange es una reformulación del polinomio de

Newton que evita el cálculo de la tabla de diferencias, el polinomio de Lagrange se
expresa como:

Donde:
P es el símbolo de “multiplicatoria” y significa el producto de.

function y0 = lagrange_interp(x, y, x0)

y0 = 0;
n = length(x);
for j = 1 : n
t = 1;
for i = 1 : n
if i~=j
t = t * (x0-x(i))/(x(j)-x(i));
end
end
y0 = y0 + t*y(j);
end

Mínimos cuadrados
El método de mínimos cuadrados sirve para interpolar valores, dicho en otras palabras, se
usa para buscar valores desconocidos usando como referencia otras muestras del mismo
evento.
function [m,b]=mincuadlin(X)
n=length(X(1,:));
A=0;
B=0;
C=0;
D=0;

for i=1:n;
A=A+X(1,i);
B=B+X(2,i);
C=C+(X(1,i))^2;
D=D+X(1,i)*X(2,i);
end

m=(n*D-A*B)/(n*C-A^2);
b=(C*B-D*A)/(n*C-A^2);
for i=1:n;
hold on;
plot (X(1,i),X(2,i),'*','MarkerEdgeColor','r','LineWidth',1);
end

x=X(1,1):1:X(1,n);
y=m*x+b;
plot(x,y,'b');
title('Aproximación lineal por mínimos cuadrados.');
end

Unidad V

Método del Trapecio

En análisis numérico la regla del trapecio es un método de integración, es decir, un
método para calcular aproximadamente el valor de una integral definida. La regla se basa
en aproximar el valor de la integral de por el de la función lineal, que pasa a través de los
puntos y.

clear all;
clc;
fprintf('Calculo de la integral por el metodo trapecial\n\n');
f=input('introduce la funcion:','s');
a=input('lime inferior:');
 b=input('limite superior:');
c=input('numero de segmentos a dividir:');
h=(b-a)/c;
z=0;
for x=a:h:b
k=eval(f);
if x==a,d=k;
end
if x==b,e=k;
end
z=z+k;
end
z=z-d-e;
z=z*2;
z=z+d+e;
z=z/(2*c);
z=z*(b-a)
fprintf('Resultado ');