Ejercicos Metodos Numericos Matlab

[UNSCH] INGENIERIA CIVIL
FACULTAD INGENIERÍA DE MINAS GEOLOGÍA Y CIVIL
“ejercicios resueltos”
El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 1

|METODOS NUMERICOS
INDICE
1. DEDICATORIA .......................................................................................................................................... 3
2. INTRODUCCION ....................................................................................................................................... 4
3. PORTADAS DELOS 2 LIBROS USADOS .................................................................................................... 5
4. RESOLUCION DE EJERCICIOS ................................................................................................................... 7
4.1. ECUACIONES NO LINEALES
4.2. ECUACIONES LINEALES
4.3. EIGEN VALORES (VALORES PROPIOS)
4.4. APROXIMACION FUNCIONAL
4.5. INTERPOLACION
4.6. INTEGRACION,DIFERENCIACION
4.7. ECUACIONES DIFERENCIALES ORDINARIAS
4.8. ECUACIONES DIFERENCIALES PARCIALES
5. ANEXO DEL PROGRAMA USADO PARA LA RESOLUCION DE EJERCICIOS “MATLAB” .......................... 182

|METODOS NUMERICOS
DEDICATORIA
Primeramente a dios por habernos permitido llegar hasta este punto y habernos dado salud,
darnos lo necesario para seguir adelante día a día para lograr nuestros objetivos.
A nuestros familiares por habernos apoyado en todo momento, por sus consejos, sus valores,
por la motivación constante que nos ha permitido ser personas de bien, pero más que nada.
A nuestra universidad por su gran apoyo y motivación para la culminación de nuestros estudios
profesionales, por su apoyo ofrecido en este trabajo, por habernos transmitidos los
conocimientos obtenidos y habernos llevado pasó a paso en el aprendizaje.
INTRODUCCION
El planeta Urano fue descubierto en 1781 por un inteligente astrónomo aficionado, Willeam
Herschel (1738 – 1822), con un telescopio de frabricación casera. Teniendo en cuenta las leyes
de Kepler, la prevista órbita de Urano fue rápidamente calculada a partir de unas pocas
observaciones muy separadas entre sí. Se encontró que la distancia media de Urano al Sol era
aproximadamente el doble que la de Saturno y que una órbita completa requería 84 años. En
1830 los datos empíricos acumulados pusieron de manifiesto desviaciones inexplicables de la
órbita prevista. Algunos astrónomos llegaron a pensar que la ley de gravitación universal de

|METODOS NUMERICOS
Newton no fuera válida para distancias tan grandes como la de Urano al Sol; otros
sospecharon que las perturbaciones fueran debidas a un cometa aún no descubierto o a un
planeta más lejano. Un estudiante de bachillerato de la Universidad de Cambridge, John Couch
Adams (1819 – 1892), estaba intrigado por la posibilidad de un planeta desconocido. Se asignó
la difícil tares de calcular la influencia de un tal planeta en las posiciones observadas de Urano,
suponiendo válida la ley de gravitación de Newton. Completó su Texto integro transcrito del
libro de Apostol; Calculus, vol 2.
Independientemente y casi simultáneamente Jean Joseph Leverrier (1811 – 1877) de París,

realizó un cálculo parecido y pidió a Johann Galle, jefe del Observatorio de Berlín, que
confirmara su predicción. La misma noche que recibió la carta de Leverrier, Galle encontró el
nuevo planeta, Neptuno, casi exactamente en la posición calculada. Éste fue otro triunfo de la
ley de gravitación de Newton y uno de los primeros grandes triunfos del análisis numérico, el
arte y la ciencia de calcular. La historia del análisis numérico data de los tiempos antiguos. Los
babilonios, 2000 años a. C. compusieron tablas matemáticas. Se ha encontradouna tabilla de
barro con los cuadrados enteros del 1 al 30. Los babilonios adoraban los cuerpos celestes y
elaboraban efemérides2 astronómicas. El famoso astrónomo alejandrino Claudio Ptolomeo
(aprox 150 d. C.) poseía unas efemérides babilónicas de ecplises que databan del año 747 a. C.
Arquímides, en el año 220 a. C., usó los polígonos regulares como aproximaciones del círculo.
El trabajo de cálculo numérico desde entonces hasta el siglo XVII fue centrado prinicpalmente
en la preparación de tablas astronómicas. El advenimiento del álgebra en el siglo XVI produjo
una renovada actividad en todas las ramas de la Matemática, incluyendo el análisis numérico.
En 1614, Neper publicó la primera tabla de logaritmos, y en 1620, los logartímos de las
funciones seno y tangente fueron tabuladas son ciete cifras decimales. Hacia 1628 habían sido
calculadas tablas de logarítmos con catorce decimales de los números 1 al 100,000.
El cálculo en series empezó a florecer hacia fines del siglo XVII, con el desarrollo del cálculo. A
principios del siglo XVIII Jacob Stirling y Brook Taylor sentaron los fundamentos del cálculo de
diferencias finitas, que ahora desempeña un papel central en el análisis numérico. Con la
predicción de la existencia y la localización del planeta Neptuno por Adam y Leverrier en 1845,
la importancia cinetífica del análisis numérico quedó establecida de una vez y para siempre. A
fines del siglo XIX, el empleo de las máquinas de cálculo atomático estimuló más aún el
desarrolllo del análisis numérico. Tal desarrollo ha sido explosivo desde la terminación de la
Segunda Guerra Mundial a causa del progreso en las máquinas de cálculo electrónicas de alta
velocidad.

|METODOS NUMERICOS

|METODOS NUMERICOS

|METODOS NUMERICOS
RESOLUCION DE EJERCICIOS DEL LIBRO “APPLIED NUMERICAL ANALYSYS- GERALD AND

WHEATLEY”
ECUACIONES NO LINEALES
TOMAMOS EJERCICIOS DEL LIBRO DE GERALD AND WHEATLEY
PRIMERO CON EL METODO BISECCION
PSEUDOCODIGO
clc
clear all
disp('================================================================
======')
disp(' MÉTODO DE BISECCIÓN
')
disp('================================================================
======')
syms ('x')
fprintf('\nIngrese la función en términos de x:\n')
s=input('\nf(x) = ','s');
c=inline(s,'x');
F=vectorize(c);
fprintf('\nIngrese el intervalo para graficar la función:\n')
xif=input('\n[Xo,Xf] = ');
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
plot(xx,Fxx,'b','LineWidth',2)

|METODOS NUMERICOS
grid on
fprintf('\nIngrese el intervalo de valores iniciales:\n')
ab=input('\n[a,b] = ');
x0=ab(1);
xf=ab(2);
I=1;
error=1;
eps=1e-5;
maxit=31;
while error>eps & I<maxit
a=x0;
b=xf;
x=(a+b)/2;
disc=F(x)*F(a);
if disc<eps
xf=x;
elseif disc>eps
x0=x;
end
error=abs(F(x));
I=I+1;
mat(I-1,:)=[a F(a) b F(b) x F(x)];
end
[fil col]=size(mat);
iter=1:fil;
mat=[iter' mat];
disp(' ')
disp(' TABLA DE ITERACIONES
')
disp(' iter a F(a) b F(b) x
F(x)')
disp(mat)
fprintf(' Solución aproximada: x = %11.8f \n',x);
fprintf(' con F(x) = %12.8f\n',F(x));

|METODOS NUMERICOS
SOLUCION

|METODOS NUMERICOS

|METODOS NUMERICOS
METODO DE LA SECANTE
PSEUDOCODIGO SECANTE
clc
clear all
disp('================================================================
======')
disp(' MÉTODO DE SECANTE
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
x0=ab(1);
xf=ab(2);
I=1;
error=1;
eps=1e-7;
maxit=31;
a=x0;
b=xf;
x=a-(b-a)*F(a)/(F(b)-F(a));
x0=xf;
xf=x;
error=abs(F(x));
I=I+1;
mat(I-1,:)=[a F(a) b F(b) x F(x)];
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
F(x)')
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN:

|METODOS NUMERICOS
MÉTODO DE LA FALSA POSICIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
disp(' MÉTODO DE FALSA POSICIÓN
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
x0=ab(1);

|METODOS NUMERICOS
xf=ab(2);
I=1;
error=1;
eps=1e-7;
maxit=31;
a=x0;
b=xf;
x=(a*F(b)-b*F(a))/(F(b)-F(a));
disc=F(x)*F(a);
if disc<eps
xf=x;
elseif disc>eps
x0=x;
end
error=abs(F(x));
I=I+1;
mat(I-1,:)=[a F(a) b F(b) x F(x)];
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
F(x)')
disp(mat)
SOLUCIÓN:

|METODOS NUMERICOS

|METODOS NUMERICOS
MÉTODO DE MULLER
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
disp(' MÉTODO DE MÜLLER
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
fprintf('\nIngrese el los valores iniciales:\n')
ab=input('\n[a,b,c] = ');
x0=ab(1);
x1=ab(2);
x2=ab(3);
I=1;
error=1;
eps=1e-7;
maxit=31;
h0=x1-x0;
h1=x2-x1;
d0=(F(x1)-F(x0))/h0;
d1=(F(x2)-F(x1))/h1;
a=(d1-d0)/(h1+h0);
b=a*h1+d1;
c=F(x2);
rad=sqrt(b^2-4*a*c);
if abs(b+rad)>abs(b-rad)
den=b+rad;
else
den=b-rad;
end
dxr=-2*c/den;
x=x2+dxr;
error=abs(dxr)/x;
x0=x1;
x1=x2;
x2=x;
I=I+1;
mat(I-1,:)=[x F(x) error*100];
end
iter=1:fil;
mat=[iter' mat];

|METODOS NUMERICOS
disp(' ')
')
disp(' iter x F(x) error(%)')
disp(mat)
SOLUCIÓN

|METODOS NUMERICOS
MÉTODO NEWTON RAPHSON
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
disp(' MÉTODO DE NEWTON RAPHSON
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
fprintf('\nIngrese el valor inicial:\n')
x0=input('\nXo = ');

|METODOS NUMERICOS
I=1;
error=1;
eps=1e-7;
maxit=31;
h=0.1; %paso para diferencias finitas
a=x0;
% diferencias finitas hacia adelante
Xad=[a+h a+2*h a+3*h a+4*h a+5*h];
dF=(-F(Xad(2))+4*F(Xad(1))-3*F(a))/(2*h);
x=a-F(a)/dF;
xad=x0;
x0=x;
error=abs(F(x));
I=I+1;
mat(I-1,:)=[a F(a) dF x F(x)];
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
disp(' iter x0 F(x0) dF(x0) x F(x)')
disp(mat)
SOLUCIÓN

|METODOS NUMERICOS

|METODOS NUMERICOS
CONCLUSIÓN
Comparando los 5 metodos, primero podemos ver que el método de muller es menos efectivo
dado que no se acerca o converge mucho a la verdadera solución, luego; a pesar de que el
método de bisección tiene varias iteraciones, nos da un valor un tanto menos cercano a los
demás, finalmente vemos que el método de newton raphson, secante y muller nos arrojan
prácticamente los mismos valores, afirmando que los mas efectivos serian estos tres, no
obstante se toman en cuenta los errores con los que trabaja cada método, considerando esto
se puede decir que el método de newton raphson es el mas eficaz, pero reiterando que los tres
métodos mencionados anteriormente tambien son eficientes.

|METODOS NUMERICOS
MÉTODO DE BISECCIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
x0=ab(1);
xf=ab(2);
I=1;
error=1;
eps=1e-5;
maxit=31;
a=x0;
b=xf;
x=(a+b)/2;
disc=F(x)*F(a);
if disc<eps
xf=x;
elseif disc>eps
x0=x;
end
error=abs(F(x));
I=I+1;
mat(I-1,:)=[a F(a) b F(b) x F(x)];
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
F(x)')
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN

|METODOS NUMERICOS
METODO DE LA SECANTE
PSEUDOCODIGO
clc
clear all
disp('================================================================
======')
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
x0=ab(1);
xf=ab(2);
I=1;
error=1;
eps=1e-7;
maxit=31;
a=x0;
b=xf;
x=a-(b-a)*F(a)/(F(b)-F(a));
x0=xf;
xf=x;
error=abs(F(x));
I=I+1;
mat(I-1,:)=[a F(a) b F(b) x F(x)];
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
F(x)')
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN
METODO DE FALSA POSICIÓN
clc
clear all
disp('================================================================
======')
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);

|METODOS NUMERICOS
grid on
x0=ab(1);
xf=ab(2);
I=1;
error=1;
eps=1e-7;
maxit=31;
a=x0;
b=xf;
x=(a*F(b)-b*F(a))/(F(b)-F(a));
disc=F(x)*F(a);
if disc<eps
xf=x;
elseif disc>eps
x0=x;
end
error=abs(F(x));
I=I+1;
mat(I-1,:)=[a F(a) b F(b) x F(x)];
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
F(x)')
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN

|METODOS NUMERICOS
MÉTODO DE MULLER
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
x0=ab(1);
x1=ab(2);
x2=ab(3);
I=1;
error=1;
eps=1e-7;
maxit=31;
h0=x1-x0;
h1=x2-x1;
d0=(F(x1)-F(x0))/h0;
d1=(F(x2)-F(x1))/h1;
a=(d1-d0)/(h1+h0);
b=a*h1+d1;
c=F(x2);
den=b+rad;
else
den=b-rad;
end
dxr=-2*c/den;
x=x2+dxr;
error=abs(dxr)/x;

|METODOS NUMERICOS
x0=x1;
x1=x2;
x2=x;
I=I+1;
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
disp(mat)
SOLUCIÓN
MÉTODO DE NEWTON RAPHSON
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
')
disp('================================================================
======')
syms ('x')

|METODOS NUMERICOS

c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
I=1;
error=1;
eps=1e-7;
maxit=31;
a=x0;
Xad=[a+h a+2*h a+3*h a+4*h a+5*h];
dF=(-F(Xad(2))+4*F(Xad(1))-3*F(a))/(2*h);
x=a-F(a)/dF;
xad=x0;
x0=x;
error=abs(F(x));
I=I+1;
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
disp(mat)
SOLUCIÓN

|METODOS NUMERICOS
CONCLUSIÓN
Utilizando estos 5 metodos y Comparandolos, primero podemos ver que en este caso el
método de bisección es el menos efectivo dado que no se acerca o converge mucho a la
verdadera solución, luego; el metodod de muller tampoco se acerca mucho a lo encontrado
con otros métodos, finalmente vemos que el método de newton raphson, secante y falsa
posicion nos arrojan soluciones muy cercanas , pero concluyendo que los mas efectivos serian
secante y newton raphson, no obstante se toman en cuenta los errores con los que trabaja
cada método, considerando esto nos podemos inclinar por el método de newton raphson que
seria el mas eficaz, dado que requiere menos iteraciones y el error es casi 0, de todas maneras
el método de la secante también es muy eficaz.

|METODOS NUMERICOS
MÉTODO DE LA BISECCIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);

|METODOS NUMERICOS
grid on
x0=ab(1);
xf=ab(2);
I=1;
error=1;
eps=1e-5;
maxit=31;
a=x0;
b=xf;
x=(a+b)/2;
disc=F(x)*F(a);
if disc<eps
xf=x;
elseif disc>eps
x0=x;
end
error=abs(F(x));
I=I+1;
mat(I-1,:)=[a F(a) b F(b) x F(x)];
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
F(x)')
disp(mat)
SOLUCIÓN

|METODOS NUMERICOS
MÉTODO DE LA SECANTE

|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
x0=ab(1);
xf=ab(2);
I=1;
error=1;
eps=1e-7;
maxit=31;
a=x0;
b=xf;
x=a-(b-a)*F(a)/(F(b)-F(a));
x0=xf;
xf=x;
error=abs(F(x));
I=I+1;
mat(I-1,:)=[a F(a) b F(b) x F(x)];
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
F(x)')
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN
MÉTODO DE LA FALSA POSICIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
x0=ab(1);

|METODOS NUMERICOS
xf=ab(2);
I=1;
error=1;
eps=1e-7;
maxit=31;
a=x0;
b=xf;
x=(a*F(b)-b*F(a))/(F(b)-F(a));
disc=F(x)*F(a);
if disc<eps
xf=x;
elseif disc>eps
x0=x;
end
error=abs(F(x));
I=I+1;
mat(I-1,:)=[a F(a) b F(b) x F(x)];
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
F(x)')
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN
MÉTODO DE MULLER
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);

|METODOS NUMERICOS
Fxx=F(xx);
grid on
x0=ab(1);
x1=ab(2);
x2=ab(3);
I=1;
error=1;
eps=1e-7;
maxit=31;
h0=x1-x0;
h1=x2-x1;
d0=(F(x1)-F(x0))/h0;
d1=(F(x2)-F(x1))/h1;
a=(d1-d0)/(h1+h0);
b=a*h1+d1;
c=F(x2);
den=b+rad;
else
den=b-rad;
end
dxr=-2*c/den;
x=x2+dxr;
error=abs(dxr)/x;
x0=x1;
x1=x2;
x2=x;
I=I+1;
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN
MÉTODO DE NEWTON RAPHSON
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
======')
')
disp('================================================================
======')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
xx=xif(1):0.1:xif(2);
Fxx=F(xx);
grid on
I=1;

|METODOS NUMERICOS
error=1;
eps=1e-7;
maxit=31;
a=x0;
Xad=[a+h a+2*h a+3*h a+4*h a+5*h];
dF=(-F(Xad(2))+4*F(Xad(1))-3*F(a))/(2*h);
x=a-F(a)/dF;
xad=x0;
x0=x;
error=abs(F(x));
I=I+1;
end
iter=1:fil;
mat=[iter' mat];
disp(' ')
')
disp(mat)
SOLUCIÓN:

|METODOS NUMERICOS

|METODOS NUMERICOS
CONCLUSIÓN
Utilizando estos 5 metodos y Comparandolos, esta vez se ve que los 5 nos dan una solución
reltivamente cercana, pero diremos que la menos efectiva fue la de bisección, luego los 4
metodos restantes nos dieron una solución prácticamente igual, pero dado al error y el
numero de iteraciones las mas efectivas fueron la de muller y la de newton raphson,
considerando también el método de la secante, finalmente podemos afirmar que el de muller
esta vez fue el mas efectivo, claro considerando la diferencia casi nula en la solución con los
métodos de newton raphson y secante.
SISTEMA DE ECUACIONES NO LINEALES
METODO DE NEWTON-RAPHSON PARA SISTEMAS DE ECUACIONES NO LINEALES
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE NEWTON-RAPHSON PARA SISTEMAS
')
disp('================================================================
===')
syms x
fprintf('\nIngrese el número de ecuaciones:\n')
N=input('\nN = ');
subtitle={'Ingrese las ecuaciones:'};

title='Lista de funciones';
def = {''};
options.Resize='on';
func = inputdlg(subtitle,title,N,def,options);
f=char(func);
fprintf('\nSistema de ecuaciones:\n\n')
for I=1:N
disp(f(I,:))
end
fprintf('\nIngrese los valores iniciales:\n')

xx=input('\n');
xx=xx';
mat(:,1)=xx;
error=1;
eps=1e-6;
k=1;

|METODOS NUMERICOS
while error>eps & k<31

k=k+1;
for I=1:N
F=inline(strcat(f(I,:)));
[jac,f0]=jacobiano(F,xx);
JAC(I,:)=jac;
F0(I,:)=f0;
end
dx=-JAC\F0;
xx=xx+dx;
mat(:,k)=xx;
error=max(abs(mat(:,k)-mat(:,k-1)));
end
iter=0:col-1;
mat=[iter;mat];
disp(' ')
disp(' TABLA DE ITERACIONES')
disp(real(mat)')
disp(' RAÍCES')
disp(real(xx)')
SOLUCIÓN

|METODOS NUMERICOS
CONCLUSIÓN
Se utilizo este metodo porque es el mas conveniente dada la cantidad de iteraciones que hace
y el error con el que trabaja además de que es el mas eficiente para la obtención de las
soluciones dado que también utiliza el jacobiano para los cálculos.

|METODOS NUMERICOS
METODO DE NEWTON-RAPHSON PARA SISTEMAS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms x
N=input('\nN = ');

def = {''};
f=char(func);
for I=1:N
disp(f(I,:))
end

xx=input('\n');
xx=xx';
mat(:,1)=xx;
error=1;
eps=1e-6;
k=1;
k=k+1;
for I=1:N
JAC(I,:)=jac;
F0(I,:)=f0;
end
dx=-JAC\F0;
xx=xx+dx;
mat(:,k)=xx;
end
iter=0:col-1;
mat=[iter;mat];
disp(' ')
disp(real(mat)')
disp(' RAÍCES')
disp(real(xx)')

|METODOS NUMERICOS
SOLUCIÓN

|METODOS NUMERICOS
CONCLUSIÓN
Nuevamente se utilizo este metodo porque es el mas conveniente además esta vez se trataba
de un sistema de ecuaciones no lineales mas complejo que el anterior, dada la cantidad de
iteraciones que hace y el error con el que trabaja es el mas eficiente para la obtención de las
soluciones dado que también utiliza el jacobiano para los cálculos.
Esta vez eligiendo un ejercicio del libro de Burden y Faires
METODO DE NEWTON-RAPHSON PARA SISTEMAS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms x
N=input('\nN = ');

def = {''};
f=char(func);
for I=1:N
disp(f(I,:))
end

|METODOS NUMERICOS

xx=input('\n');
xx=xx';
mat(:,1)=xx;
error=1;
eps=1e-6;
k=1;
k=k+1;
for I=1:N
JAC(I,:)=jac;
F0(I,:)=f0;
end
dx=-JAC\F0;
xx=xx+dx;
mat(:,k)=xx;
end
iter=0:col-1;
mat=[iter;mat];
disp(' ')
disp(real(mat)')
disp(' RAÍCES')
disp(real(xx)')

|METODOS NUMERICOS
SOLUCIÓN
CONCLUSIÓN
Para este ejercicio también se empleo el metodo de newton raphson para sistemas dado que
es el más apropiado por el numeo de iteraciones que realiza y su cercanía a las soluciones
esperadas, además utiliza el jacobiano para los cálculos.

|METODOS NUMERICOS
SISTEMA DE ECUACIONES LINEALES (GERALD)
MÉTODO DE ELIMINACIÓN GAUSSIANA
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE ELIMINACIÓN GAUSSIANA
')
disp('================================================================
===')
fprintf('\nIngrese la matriz de coeficientes:\n')
fprintf('\nA = \n')
A=input('');
fprintf('\nIngrese el vector de términos independientes:\n')
fprintf('\nB = \n')
B=input('');
eps=1e-4;
maxit=31;
N=length(B);
for k=1:N-1
for m=k+1:N
MT=-A(m,k)/A(k,k);
A(m,:)=A(m,:)+MT*A(k,:);
B(m)=B(m)+MT*B(k);
end
end
x(N)=B(N)/A(N,N);
for k=N-1:-1:1
ind=N-k;
x(k)=0;
for m=1:ind
x(k)=x(k)-A(k,k+m)*x(k+m);
end
x(k)=(B(k)+x(k))/A(k,k);
end
disp(' ')
disp(' RAÍCES')
disp(x')

|METODOS NUMERICOS
SOLUCIÓN
MÉTODO DE GAUSS-JORDAN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE GAUSS-JORDAN
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
eps=1e-4;
maxit=31;
N=length(B);
for k=1:N
B(k)=B(k)/A(k,k);
A(k,:)=A(k,:)/A(k,k);
for m=1:N
if m~=k
MT=-A(m,k);
A(m,:)=A(m,:)+MT*A(k,:);
B(m)=B(m)+MT*B(k);
end
end
end

|METODOS NUMERICOS
x=B;
disp(' ')
disp(' RAÍCES')
disp(x)
SOLUCIÓN
MÉTODO DE FACTORIZACIÓN LU
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE FACTORIZACIÓN LU
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
eps=1e-4;
maxit=31;
N=length(B);
U=A;
for I=1:N-1

|METODOS NUMERICOS
for J=I+1:N
MT=-U(J,I)/U(I,I);
U(J,:)=U(J,:)+MT*U(I,:);
end
end
L=eye(N);
L(2:N,1)=A(2:N,1)/U(1,1);
for I=2:N-1
for J=I+1:N
MT=0;
for k=1:I-1
MT=MT-L(J:N,k).*U(k,I);
end
L(J:N,I)=(A(J:N,I)+MT)./U(I,I);
end
end
aux(1)=B(1);
for k=2:N
ind=k-1;
aux(k)=0;
for m=1:ind
aux(k)=aux(k)-L(k,k-m)*aux(k-m);
end
aux(k)=B(k)+aux(k);
end
x(N)=aux(N)/U(N,N);
for k=N-1:-1:1
ind=N-k;
x(k)=0;
for m=1:ind
x(k)=x(k)-U(k,k+m)*x(k+m);
end
x(k)=(aux(k)+x(k))/U(k,k);
end
disp(' ')
disp(' RAÍCES')
disp(x')

|METODOS NUMERICOS
SOLUCIÓN
MÉTODO DE JACOBI
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE JACOBI
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
fprintf('\nIngrese el vector de valores iniciales\n')
fprintf('\nXo = \n')
x0=input('');
eps=1e-4;
maxit=31;
N=length(B);
DA=diag(A);
D=diag(DA);
A=A-D;
M=-inv(D)*A;
h=inv(D)*B;
x(:,1)=x0;
|METODOS NUMERICOS
error=1;
J=2;
while error>eps & J<maxit
x(:,J)=M*x(:,J-1)+h;
error=max(abs(x(:,J)-x(:,J-1)));
J=J+1;
end
nit=J-2;
disp(' ')
disp(x')
disp(' RAÍCES')
disp(x(:,nit+1)')

|METODOS NUMERICOS
SOLUCIÓN

|METODOS NUMERICOS

|METODOS NUMERICOS
MÉTODO DE GAUSS-SEIDEL
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE GAUSS-SEIDEL
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
x0=input('');
eps=1e-4;
maxit=31;
N=length(B);
DA=diag(A);
D=diag(DA);
A=A-D;
for I=1:N
L(I:N,I)=A(I:N,I);
U(I,I:N)=A(I,I:N);
end
M=-inv(D+L)*U;
h=inv(D+L)*B;
x(:,1)=x0;
error=1;
J=2;
x(:,J)=M*x(:,J-1)+h;
J=J+1;
end
nit=J-2;
disp(' ')
disp(x')
disp(' RAÍCES')
disp(x(:,nit+1)')
SOLUCIÓN

|METODOS NUMERICOS

|METODOS NUMERICOS
CONCLUSIÓN
Comparando los 5 metodos, primero podemos ver que el método de JACOBI a pesar de tantas
iteraciones no muestra soluciones relativamente iguales a la de los otros métodos empleados,
luego se ve también que los otros 4 metodos restantes arrojan las mismas soluciones, siendo
el método de GAUSS SEIDEL el que emplea mas iteraciones en comparación con los métodos
restantes, los 4 metodos resultan eficaces, pero reiterando que todos los métodos
mencionados anteriormente son eficientes.
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
eps=1e-4;
maxit=31;
N=length(B);
for k=1:N-1
for m=k+1:N
MT=-A(m,k)/A(k,k);
A(m,:)=A(m,:)+MT*A(k,:);
B(m)=B(m)+MT*B(k);
end
end
x(N)=B(N)/A(N,N);
for k=N-1:-1:1
ind=N-k;

|METODOS NUMERICOS
x(k)=0;
for m=1:ind
end
x(k)=(B(k)+x(k))/A(k,k);
end
disp(' ')
disp(' RAÍCES')
disp(x')
SOLUCIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
eps=1e-4;

|METODOS NUMERICOS
maxit=31;
N=length(B);
for k=1:N
B(k)=B(k)/A(k,k);
A(k,:)=A(k,:)/A(k,k);
for m=1:N
if m~=k
MT=-A(m,k);
A(m,:)=A(m,:)+MT*A(k,:);
B(m)=B(m)+MT*B(k);
end
end
end
x=B;
disp(' ')
disp(' RAÍCES')
disp(x)
SOLUCIÓN

|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
eps=1e-4;
maxit=31;
N=length(B);
U=A;
for I=1:N-1
for J=I+1:N
MT=-U(J,I)/U(I,I);
U(J,:)=U(J,:)+MT*U(I,:);
end
end
L=eye(N);
L(2:N,1)=A(2:N,1)/U(1,1);
for I=2:N-1
for J=I+1:N
MT=0;
for k=1:I-1
end
end
end
aux(1)=B(1);
for k=2:N
ind=k-1;
aux(k)=0;
for m=1:ind
end
aux(k)=B(k)+aux(k);
end
x(N)=aux(N)/U(N,N);
for k=N-1:-1:1
ind=N-k;
x(k)=0;
for m=1:ind
end

|METODOS NUMERICOS
end
disp(' ')
disp(' RAÍCES')
disp(x')
SOLUCIÓN
CONCLUSIÓN
Esta vez se utilizo tres métodos diferentes, resultando las mismas soluciones por estos tres
métodos en este caso diremos que los tres métodos (eliminacion Gaussiana, Gauss Jordan y
factorizaion LU) convergen en una misma solución la cual comparándola con el libro es muy
cercana.

|METODOS NUMERICOS
MÉTODO DE JACOBI
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE JACOBI
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
x0=input('');
eps=1e-4;
maxit=31;
N=length(B);
DA=diag(A);
D=diag(DA);
A=A-D;
M=-inv(D)*A;
h=inv(D)*B;
x(:,1)=x0;
error=1;
J=2;
x(:,J)=M*x(:,J-1)+h;
J=J+1;
end
nit=J-2;
disp(' ')
disp(x')
disp(' RAÍCES')
disp(x(:,nit+1)')

|METODOS NUMERICOS
SOLUCIÓN

|METODOS NUMERICOS

|METODOS NUMERICOS
MÉTODO DE GAUSS-SEIDEL
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE GAUSS-SEIDEL
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
x0=input('');
eps=1e-4;
maxit=31;
N=length(B);
DA=diag(A);
D=diag(DA);
A=A-D;
for I=1:N
L(I:N,I)=A(I:N,I);
U(I,I:N)=A(I,I:N);
end
M=-inv(D+L)*U;
h=inv(D+L)*B;
x(:,1)=x0;
error=1;
J=2;
x(:,J)=M*x(:,J-1)+h;
J=J+1;
end
nit=J-2;
disp(' ')
disp(x')
disp(' RAÍCES')
disp(x(:,nit+1)')
SOLUCIÓN

|METODOS NUMERICOS

|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
eps=1e-4;
maxit=31;
N=length(B);
for k=1:N-1
for m=k+1:N
MT=-A(m,k)/A(k,k);
A(m,:)=A(m,:)+MT*A(k,:);
B(m)=B(m)+MT*B(k);
end
end
x(N)=B(N)/A(N,N);
for k=N-1:-1:1
ind=N-k;
x(k)=0;
for m=1:ind
end
x(k)=(B(k)+x(k))/A(k,k);
end
disp(' ')
disp(' RAÍCES')
disp(x')
SOLUCIÓN

|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
eps=1e-4;
maxit=31;
N=length(B);
for k=1:N
B(k)=B(k)/A(k,k);
A(k,:)=A(k,:)/A(k,k);
for m=1:N
if m~=k
MT=-A(m,k);
A(m,:)=A(m,:)+MT*A(k,:);
B(m)=B(m)+MT*B(k);
end
end
end
x=B;
disp(' ')

|METODOS NUMERICOS
disp(' RAÍCES')
disp(x)
SOLUCIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
fprintf('\nA = \n')
A=input('');
fprintf('\nB = \n')
B=input('');
eps=1e-4;
maxit=31;
N=length(B);
U=A;
for I=1:N-1
for J=I+1:N
MT=-U(J,I)/U(I,I);

|METODOS NUMERICOS
U(J,:)=U(J,:)+MT*U(I,:);
end
end
L=eye(N);
L(2:N,1)=A(2:N,1)/U(1,1);
for I=2:N-1
for J=I+1:N
MT=0;
for k=1:I-1
end
end
end
aux(1)=B(1);
for k=2:N
ind=k-1;
aux(k)=0;
for m=1:ind
end
aux(k)=B(k)+aux(k);
end
x(N)=aux(N)/U(N,N);
for k=N-1:-1:1
ind=N-k;
x(k)=0;
for m=1:ind
end
end
disp(' ')
disp(' RAÍCES')
disp(x')
SOLUCIÓN

|METODOS NUMERICOS

|METODOS NUMERICOS
CONCLUSIÓN
Comparando los 5 metodos, primero podemos ver que el método de JACOBI a pesar de tantas
iteraciones no muestra soluciones relativamente iguales a la de los otros métodos empleados,
luego se ve también que los otros 4 metodos restantes arrojan las mismas soluciones
exceptuando al método de GAUSS SEIDEL que se elja un tanto de los tres métodos restantes,
los 3 metodos resultan eficaces, pero reiterando que todos los métodos mencionados
anteriormente son eficientes.
INTERPOLACION (GERALD)
MÉTODO DE LAGRANGE
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE LAGRANGE
')
disp('================================================================
===')
format short
fprintf('\nIngrese los datos como vectores:\n')
X=input('\nX = ');
FX=input('\nF(X) = ');
fprintf('\nIngrese el valor que desea interpolar:\n')
Xint=input('\nx = ');
N=length(X);
FXint=0;
syms x
for I=1:N
g=1;
for J=1:N

|METODOS NUMERICOS
if I~=J
g=g*(x-X(J))/(X(I)-X(J));
end
end
FXint=FXint+g*FX(I);
end
FXint=char(vpa(simplify(FXint),7));
disp(' ')
disp(' POLINOMIO INTERPOLADOR')
fprintf(' P(x) = ')
disp(FXint)
FXint=inline(FXint,'x');
fprintf(' Valor interpolado: f(x) = %f \n',FXint(Xint));
SOLUCIÓN
MÉTODO DE NEWTON
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE NEWTON
')
disp('================================================================
===')
format short
X=input('\nX = ');
N=length(X);

|METODOS NUMERICOS
FXint=0;
for I=1:N-1
T(I,1)=(FX(I+1)-FX(I))/(X(I+1)-X(I));
end
for J=2:N-1
for I=J:N-1
T(I-J+1,J)=(T(I-J+2,J-1)-T(I-J+1,J-1))/(X(I+1)-X(I-J+1));
end
end
syms x
for I=1:N-1
P=1;
for J=1:I
P=P*(x-X(J));
end
FXint=FXint+T(1,I)*P;
end
FXint=FXint+FX(1);
disp(' ')
fprintf(' P(x) = ')
disp(FXint)
SOLUCIÓN

|METODOS NUMERICOS
MÉTODO DE SPLINE CÚBICO
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE SPLINE CÚBICO
')
disp('================================================================
===')
format short
X=input('\nX = ');
N=length(X);
for I=1:N-1
h(I)=X(I+1)-X(I);
e(I)=(FX(I+1)-FX(I))/h(I);
end
for I=1:N-2
for J=1:N-2
if I==J
A(I,J)=(h(I)+h(I+1))/3;
elseif J==I-1
A(I,J)=h(I)/6;
elseif J==I+1
A(I,J)=h(J)/6;
end
end
end
for I=2:N-1
cte(I-1)=e(I)-e(I-1);
end
r=inv(A)*cte';
r=[0;r;0];
for I=1:N-1
a(I)=(r(I+1)-r(I))/(6*h(I));
b(I)=r(I)/2;
c(I)=(FX(I+1)-FX(I))/h(I)-(r(I+1)/6+r(I)/3)*h(I);
d(I)=FX(I);
end
for I=1:N-1
dd(I)=d(I)-c(I)*X(I)+b(I)*X(I)^2-a(I)*X(I)^3;
cc(I)=c(I)-2*b(I)*X(I)+3*a(I)*X(I)^2;
bb(I)=b(I)-3*a(I)*X(I);
aa(I)=a(I);
end
mat=[aa' bb' cc' dd'];
for I=1:N-1
if Xint>X(I) & Xint<X(I+1)

|METODOS NUMERICOS
FXint=aa(I)*Xint^3+bb(I)*Xint^2+cc(I)*Xint+dd(I);
end
end
disp(' ')
disp(' COEFICIENTES DEL POLINOMIO INTERPOLADOR')
disp(' a b c d')
disp(mat)
fprintf(' Valor interpolado: f(x) = %f \n',FXint);
SOLUCIÓN
CONCLUSIÓN
Esta vez utilizando tres métodos diferentes, se ve que el resultado de lagrange y newton
prácticamente nos da la misma expresión, resultando que spline cubico se aproxima
relativamente.

|METODOS NUMERICOS
MÉTODO DE LAGRANGE
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
format short
X=input('\nX = ');
N=length(X);
FXint=0;
syms x
for I=1:N
g=1;
for J=1:N
if I~=J
g=g*(x-X(J))/(X(I)-X(J));
end
end
end
disp(' ')
fprintf(' P(x) = ')
disp(FXint)

|METODOS NUMERICOS
SOLUCIÓN
MÉTODO DE NEWTON
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
format short
X=input('\nX = ');

|METODOS NUMERICOS

N=length(X);
FXint=0;
for I=1:N-1
T(I,1)=(FX(I+1)-FX(I))/(X(I+1)-X(I));
end
for J=2:N-1
for I=J:N-1
end
end
syms x
for I=1:N-1
P=1;
for J=1:I
P=P*(x-X(J));
end
end
FXint=FXint+FX(1);
disp(' ')
fprintf(' P(x) = ')
disp(FXint)
SOLUCIÓN

|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
format short
X=input('\nX = ');
N=length(X);
for I=1:N-1
h(I)=X(I+1)-X(I);
e(I)=(FX(I+1)-FX(I))/h(I);
end
for I=1:N-2
for J=1:N-2
if I==J
A(I,J)=(h(I)+h(I+1))/3;
elseif J==I-1
A(I,J)=h(I)/6;
elseif J==I+1
A(I,J)=h(J)/6;
end
end
end
for I=2:N-1
cte(I-1)=e(I)-e(I-1);
end
r=inv(A)*cte';
r=[0;r;0];
for I=1:N-1
a(I)=(r(I+1)-r(I))/(6*h(I));
b(I)=r(I)/2;
d(I)=FX(I);
end
for I=1:N-1
cc(I)=c(I)-2*b(I)*X(I)+3*a(I)*X(I)^2;
bb(I)=b(I)-3*a(I)*X(I);
aa(I)=a(I);
end
for I=1:N-1
end
end
disp(' ')

|METODOS NUMERICOS
disp(' a b c d')
disp(mat)
SOLUCIÓN
CONCLUSIÓN
Utilizando tres métodos diferentes, se ve que el resultado de lagrange y newton

prácticamente nos da la misma expresión, resultando que spline cubico se aproxima
relativamente.

|METODOS NUMERICOS
MÉTODO DE LAGRANGE
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
format short
X=input('\nX = ');
N=length(X);
FXint=0;
syms x
for I=1:N
g=1;
for J=1:N
if I~=J
g=g*(x-X(J))/(X(I)-X(J));
end
end
end
disp(' ')
fprintf(' P(x) = ')
disp(FXint)

|METODOS NUMERICOS
SOLUCIÓN
MÉTODO DE NEWTON
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
format short

|METODOS NUMERICOS

X=input('\nX = ');
N=length(X);
FXint=0;
for I=1:N-1
T(I,1)=(FX(I+1)-FX(I))/(X(I+1)-X(I));
end
for J=2:N-1
for I=J:N-1
end
end
syms x
for I=1:N-1
P=1;
for J=1:I
P=P*(x-X(J));
end
end
FXint=FXint+FX(1);
disp(' ')
fprintf(' P(x) = ')
disp(FXint)
SOLUCIÓN

|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
format short
X=input('\nX = ');
N=length(X);
for I=1:N-1
h(I)=X(I+1)-X(I);
e(I)=(FX(I+1)-FX(I))/h(I);
end
for I=1:N-2
for J=1:N-2
if I==J
A(I,J)=(h(I)+h(I+1))/3;
elseif J==I-1
A(I,J)=h(I)/6;
elseif J==I+1
A(I,J)=h(J)/6;
end
end
end
for I=2:N-1
cte(I-1)=e(I)-e(I-1);
end
r=inv(A)*cte';
r=[0;r;0];
for I=1:N-1
a(I)=(r(I+1)-r(I))/(6*h(I));
b(I)=r(I)/2;
d(I)=FX(I);
end
for I=1:N-1
cc(I)=c(I)-2*b(I)*X(I)+3*a(I)*X(I)^2;
bb(I)=b(I)-3*a(I)*X(I);
aa(I)=a(I);
end
for I=1:N-1
end
end

|METODOS NUMERICOS
disp(' ')
disp(' a b c d')
disp(mat)
SOLUCIÓN
CONCLUSIÓN

|METODOS NUMERICOS
También utilizando tres métodos diferentes, se ve que el resultado de lagrange y newton nos
dan una expresión similar pero que difiere de todas maneras, luego spline cubico se aproxima
relativamente, en este caso el mejor método seria el de lagrange.

|METODOS NUMERICOS
APROXIMACION (GERALD)
MÉTODO DE CHEBYSHEV
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE CHEBYSHEV
')
disp('================================================================
===')
syms x
fprintf('\nIngrese la función:\n')
c=inline(s,'x');
F=vectorize(c);
fprintf('\nIngrese el grado del polinomio aproximado:\n')
N=input('\nN = ');
fprintf('\nIngrese el intervalo en el que desea aproximar:\n')
a=ab(1);
b=ab(2);
d=pi/(2*N+2);
C=zeros(1,N+1);
for I=1:N+1
X(I)=cos((2*I-1)*d);
end
X=(b-a)*X/2+(a+b)/2;
xx=X;
Y=F(xx);
for I=1:N+1
z=(2*I-1)*d;
for J=1:N+1
C(J)=C(J)+Y(I)*cos((J-1)*z);
end
end
C=2*C/(N+1);
C(1)=C(1)/2;
T=[0 0 0 0 0 0 0 1;...
0 0 0 0 0 0 1 0;...
0 0 0 0 0 2 0 -1;...
0 0 0 0 4 0 -3 0;...
0 0 0 8 0 -8 0 1;...
0 0 16 0 -20 0 5 0;...
0 32 0 -48 0 18 0 -1;...
64 0 -112 0 56 0 -7 0];

|METODOS NUMERICOS
for I=1:N+1
P(I,:)=C(I)*T(I,8-N:8);
end
for I=1:N+1
CP(I)=sum(P(:,I));
end
poli=CP(N+1);
for I=1:N
poli=poli+CP(length(CP)-I)*x^I;
end
FXint=char(vpa(poli,4));
disp(' ')
disp(' POLINOMIO APROXIMADO')
fprintf(' P(x) = ')
disp(FXint)
disp(' ')
FXint=vectorize(FXint);
int=a:0.1:b;
mat=[int' F(int)' FXint(int)' (F(int)-FXint(int))'];
disp(' VALORES APROXIMADOS')
disp(' x f(x) Chebyshev error')
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN
MÉTODO DE MÍNIMOS CUADRADOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE MÍNIMOS CUADRADOS
')
disp('================================================================
===')
syms x
c=inline(s,'x');
F=vectorize(c);
P=input('\nN = ');

|METODOS NUMERICOS
a=ab(1);
b=ab(2);
X=a:0.1:b;
FX=F(X);
N=P+1;
for k=1:2*P+1
aa(k,1)=sum(X.^(k-1));
end
for k=1:N
A(:,k)=aa(k:N+k-1);
end
for k=1:N
Y(k,1)=sum(FX.*X.^(k-1));
end
CP=inv(A)*Y;
poli=CP(1);
for I=1:P
poli=poli+CP(I+1)*x^I;
end
disp(' ')
fprintf(' P(x) = ')
disp(FXint)
disp(' ')
int=a:0.1:b;
disp(' x f(x) Min. Cuad. error')
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms x

|METODOS NUMERICOS
c=inline(s,'x');
F=vectorize(c);
N=input('\nN = ');
a=ab(1);
b=ab(2);
d=pi/(2*N+2);
C=zeros(1,N+1);
for I=1:N+1
X(I)=cos((2*I-1)*d);
end
X=(b-a)*X/2+(a+b)/2;
xx=X;
Y=F(xx);
for I=1:N+1
z=(2*I-1)*d;
for J=1:N+1
C(J)=C(J)+Y(I)*cos((J-1)*z);
end
end
C=2*C/(N+1);
C(1)=C(1)/2;
T=[0 0 0 0 0 0 0 1;...
0 0 0 0 0 0 1 0;...
0 0 0 0 0 2 0 -1;...
0 0 0 0 4 0 -3 0;...
0 0 0 8 0 -8 0 1;...
0 0 16 0 -20 0 5 0;...
0 32 0 -48 0 18 0 -1;...
64 0 -112 0 56 0 -7 0];
for I=1:N+1
P(I,:)=C(I)*T(I,8-N:8);
end
for I=1:N+1
CP(I)=sum(P(:,I));
end
poli=CP(N+1);
for I=1:N
end
disp(' ')
fprintf(' P(x) = ')
disp(FXint)
disp(' ')
int=a:0.1:b;
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms x

|METODOS NUMERICOS
c=inline(s,'x');
F=vectorize(c);
P=input('\nN = ');
a=ab(1);
b=ab(2);
X=a:0.1:b;
FX=F(X);
N=P+1;
for k=1:2*P+1
aa(k,1)=sum(X.^(k-1));
end
for k=1:N
A(:,k)=aa(k:N+k-1);
end
for k=1:N
Y(k,1)=sum(FX.*X.^(k-1));
end
CP=inv(A)*Y;
poli=CP(1);
for I=1:P
end
disp(' ')
fprintf(' P(x) = ')
disp(FXint)
disp(' ')
int=a:0.1:b;
disp(mat)

|METODOS NUMERICOS
SOLUCIÓN
CONCLUSIÓN
Utilizando 2 métodos diferentes (CHEBYSHEV y MINIMOS CUADRADOS), se ve que el resultado

cuando las soluciones nos dan una curva de grado 5 son mas aproximadas que cuando los
métodos nos dan la curva de grado 4, ambos métodos son bastante eficientes.
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms x
c=inline(s,'x');
F=vectorize(c);
N=input('\nN = ');
a=ab(1);
b=ab(2);
d=pi/(2*N+2);
C=zeros(1,N+1);
for I=1:N+1
X(I)=cos((2*I-1)*d);
end
X=(b-a)*X/2+(a+b)/2;
xx=X;
Y=F(xx);
for I=1:N+1
z=(2*I-1)*d;
for J=1:N+1
C(J)=C(J)+Y(I)*cos((J-1)*z);
end
end
C=2*C/(N+1);
C(1)=C(1)/2;
T=[0 0 0 0 0 0 0 1;...
0 0 0 0 0 0 1 0;...
0 0 0 0 0 2 0 -1;...
0 0 0 0 4 0 -3 0;...
0 0 0 8 0 -8 0 1;...
|METODOS NUMERICOS
0 0 16 0 -20 0 5 0;...
0 32 0 -48 0 18 0 -1;...
64 0 -112 0 56 0 -7 0];
for I=1:N+1
P(I,:)=C(I)*T(I,8-N:8);
end
for I=1:N+1
CP(I)=sum(P(:,I));
end
poli=CP(N+1);
for I=1:N
end
disp(' ')
fprintf(' P(x) = ')
disp(FXint)
disp(' ')
int=a:0.1:b;
disp(mat)
SOLUCIÓN
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms x
c=inline(s,'x');
F=vectorize(c);
P=input('\nN = ');
|METODOS NUMERICOS
a=ab(1);
b=ab(2);
X=a:0.1:b;
FX=F(X);
N=P+1;
for k=1:2*P+1
aa(k,1)=sum(X.^(k-1));
end
for k=1:N
A(:,k)=aa(k:N+k-1);
end
for k=1:N
Y(k,1)=sum(FX.*X.^(k-1));
end
CP=inv(A)*Y;
poli=CP(1);
for I=1:P
end
disp(' ')
fprintf(' P(x) = ')
disp(FXint)
disp(' ')
int=a:0.1:b;
disp(mat)
SOLUCIÓN
|METODOS NUMERICOS
CONCLUSIÓN
Utilizando 2 métodos diferentes (CHEBYSHEV y MINIMOS CUADRADOS), se ve que el resultado

de las curvas aproximadas difiere bastante en sus coeficientes pero la aproximación es muy
parecida, dando un mejor resultado en este caso el método de minimos cuadrados.
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms x
c=inline(s,'x');
F=vectorize(c);
N=input('\nN = ');
a=ab(1);
b=ab(2);
d=pi/(2*N+2);
C=zeros(1,N+1);
for I=1:N+1
X(I)=cos((2*I-1)*d);
end
X=(b-a)*X/2+(a+b)/2;
xx=X;
Y=F(xx);
for I=1:N+1
z=(2*I-1)*d;
for J=1:N+1
C(J)=C(J)+Y(I)*cos((J-1)*z);
end
end
C=2*C/(N+1);
C(1)=C(1)/2;
T=[0 0 0 0 0 0 0 1;...
0 0 0 0 0 0 1 0;...
0 0 0 0 0 2 0 -1;...
0 0 0 0 4 0 -3 0;...
0 0 0 8 0 -8 0 1;...
0 0 16 0 -20 0 5 0;...
0 32 0 -48 0 18 0 -1;...
64 0 -112 0 56 0 -7 0];
for I=1:N+1
P(I,:)=C(I)*T(I,8-N:8);
end
for I=1:N+1
CP(I)=sum(P(:,I));
end
poli=CP(N+1);
for I=1:N
|METODOS NUMERICOS
end
disp(' ')
fprintf(' P(x) = ')
disp(FXint)
disp(' ')
int=a:0.1:b;
disp(mat)
|METODOS NUMERICOS
SOLUCIÓN
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms x
c=inline(s,'x');
F=vectorize(c);
P=input('\nN = ');
a=ab(1);
b=ab(2);
X=a:0.1:b;
FX=F(X);
N=P+1;
for k=1:2*P+1
aa(k,1)=sum(X.^(k-1));
end
for k=1:N
A(:,k)=aa(k:N+k-1);
end
for k=1:N
Y(k,1)=sum(FX.*X.^(k-1));
end
CP=inv(A)*Y;
poli=CP(1);
for I=1:P
end
disp(' ')
fprintf(' P(x) = ')
disp(FXint)
disp(' ')
int=a:0.1:b;
disp(mat)
|METODOS NUMERICOS
SOLUCIÓN
CONCLUSIÓN
Esta vez utilizando 2 métodos diferentes (CHEBYSHEV y MINIMOS CUADRADOS), se ve que el

resultado de las curvas aproximadas es bastante similar incluso en coeficientes, dando un
mejor resultado en este caso el método de minimos cuadrados.
|METODOS NUMERICOS
|METODOS NUMERICOS
DIFERENCIACION (GERALD)
MÉTODO DE DIFERENCIAS FINITAS HACIA ADELANTE
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE DIFERENCIAS FINITAS HACIA ADELANTE
')
disp('================================================================
===')
syms ('x')
fprintf('\nIngrese la función que desea derivar:\n')
F=inline(s,'x');
fprintf('\nIngrese el valor para la derivada:\n')
x=input('\nx = ');
h=0.1;
Xad=[x+h x+2*h x+3*h x+4*h x+5*h];
DER=(-F(Xad(2))+4*F(Xad(1))-3*F(x))/(2*h);
disp(' ')
disp(' RESULTADO')
fprintf(' Derivada aproximada: D = %11.8f \n',DER);
SOLUCIÓN
|METODOS NUMERICOS
MÉTODO DE DIFERENCIAS FINITAS HACIA ATRÁS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE DIFERENCIAS FINITAS HACIA ATRÁS
')
disp('================================================================
===')
syms ('x')
F=inline(s,'x');
x=input('\nx = ');
h=0.1;
Xat=[x-h x-2*h x-3*h x-4*h x-5*h];
DER=(3*F(x)-4*F(Xat(1))+F(Xat(2)))/(2*h);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
|METODOS NUMERICOS
MÉTODO DE DIFERENCIAS FINITAS CENTRALES
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE DIFERENCIAS FINITAS CENTRALES
')
disp('================================================================
===')
syms ('x')
F=inline(s,'x');
x=input('\nx = ');
h=0.1;
Xat=[x-h x-2*h x-3*h x-4*h x-5*h];
Xad=[x+h x+2*h x+3*h x+4*h x+5*h];
DER=(-F(Xad(2))+8*F(Xad(1))-8*F(Xat(1))+F(Xat(2)))/(12*h);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
CONCLUSIÓN
Utilizando tres métodos diferentes, se ve que el resultado de diferencias finitas hacia

adelante nos da un valor relativamente lejano al de los otros dos métodos, en este caso
diremos que diferencias finitas hacia atrás y diferencias finitas centrales son más efectivos.
|METODOS NUMERICOS
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
F=inline(s,'x');
x=input('\nx = ');
h=0.1;
Xad=[x+h x+2*h x+3*h x+4*h x+5*h];
DER=(-F(Xad(2))+4*F(Xad(1))-3*F(x))/(2*h);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
F=inline(s,'x');
x=input('\nx = ');
h=0.1;
Xat=[x-h x-2*h x-3*h x-4*h x-5*h];
DER=(3*F(x)-4*F(Xat(1))+F(Xat(2)))/(2*h);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
F=inline(s,'x');
x=input('\nx = ');
h=0.1;
Xat=[x-h x-2*h x-3*h x-4*h x-5*h];
Xad=[x+h x+2*h x+3*h x+4*h x+5*h];
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
CONCLUSIÓN
|METODOS NUMERICOS
Utilizando tres métodos diferentes, en este caso se ve que el resultado de diferencias finitas
hacia atrás nos da un valor relativamente lejano al de los otros dos métodos, por lo tanto
diremos que diferencias finitas hacia adelante y diferencias finitas centrales son más efectivos.
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
F=inline(s,'x');
x=input('\nx = ');
h=0.1;
Xad=[x+h x+2*h x+3*h x+4*h x+5*h];
DER=(-F(Xad(2))+4*F(Xad(1))-3*F(x))/(2*h);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
F=inline(s,'x');
x=input('\nx = ');
h=0.1;
Xat=[x-h x-2*h x-3*h x-4*h x-5*h];
DER=(3*F(x)-4*F(Xat(1))+F(Xat(2)))/(2*h);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
F=inline(s,'x');
x=input('\nx = ');
h=0.1;
Xat=[x-h x-2*h x-3*h x-4*h x-5*h];
Xad=[x+h x+2*h x+3*h x+4*h x+5*h];
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
CONCLUSIÓN
Utilizando tres métodos diferentes, en este caso se ve que los tres métodos nos dan una
solución muy cercana, pero el menos cercano es esta vez el de diferencias finitas centrales, por
|METODOS NUMERICOS
lo tanto diremos que diferencias finitas hacia adelante y diferencias finitas hacia atras son los
más efectivos.
|METODOS NUMERICOS
INTEGRACION (GERALD)
MÉTODO DEL TRAPECIO
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DEL TRAPECIO
')
disp('================================================================
===')
syms ('x')
fprintf('\nIngrese la función que desea integrar:\n')
c=inline(s,'x');
F=vectorize(c);
fprintf('\nIngrese los límites de integración:\n')
a=ab(1);
b=ab(2);
N=1;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
k=1;
Irt(k)=(h/2)*sum(fx);
tol=1;
while tol>0.0001
N=2*N;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
Sp=length(fx);
k=k+1;
Irt(k)=(h/2)*(fx(1)+2*sum(fx(2:Sp-1))+fx(Sp));
tol=abs(Irt(k)-Irt(k-1));
end
Irt(k);
disp(' ')
disp(' RESULTADO')
fprintf(' Integral aproximada: I = %11.8f \n',Irt(k));
|METODOS NUMERICOS
SOLUCIÓN
MÉTODO DE SIMPSON 1/3
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE SIMPSOM 1/3
')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=2;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
k=1;
Is1(k)=(h/3)*(fx(1)+4*fx(2)+fx(3));
tol=1;
while tol>0.0001
N=2*N;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
Sp=length(fx);
k=k+1;
Is1(k)=(h/3)*(fx(1)+4*sum(fx(2:2:Sp-1))+2*sum(fx(3:2:Sp-
2))+fx(Sp));
tol=abs(Is1(k)-Is1(k-1));
end
|METODOS NUMERICOS
Is1(k);
disp(' ')
disp(' RESULTADO')
fprintf(' Integral aproximada: I = %11.8f \n',Is1(k));
SOLUCIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=3;
H=(b-a)/N;
X=(a:H:b);
fx=F(X);
k=1;
Is3(k)=3*H/8*(fx(1)+3*fx(2)+3*fx(3)+4*fx(4));
tol=1;
while tol>0.0001
N=2*N;
H=(b-a)/N;
X=(a:H:b);
fx=F(X);
|METODOS NUMERICOS
Sp=length(fx);
k=k+1;
Is3(k)=3*H/8*(fx(1)+3*sum(fx(2:3:Sp-2))+3*sum(fx(3:3:Sp-
1))+2*sum(fx(4:3:Sp-1))+fx(Sp));
end
Is3(k);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN:
MÉTODO DE CUADRATURA DE GAUSS DE 2 PUNTOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE CUADRATURA DE GAUSS DE 2 PUNTOS
')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=2;
H=(b-a)/(N/2);
R=[-1/sqrt(3) 1/sqrt(3)];
X=((b-a).*R+b+a)/2;
fx=F(X);
k=1;
Igauss2(k)=(H/2)*sum(fx);
|METODOS NUMERICOS
tol=1;
c1=a;
c2=b;
while tol>0.0001
N=2*N;
H=(c2-c1)/(N/2);
n=(a:H:b);
X=[];
for I=1:length(n)-1
c1=n(I);
c2=n(I+1);
X=[X ((c2-c1).*R+c2+c1)/2];
end
fx=F(X);
k=k+1;
Igauss2(k)=H/2*sum(fx);
tol=abs(Igauss2(k)-Igauss2(k-1));
end
Igauss2(k);
disp(' ')
disp(' RESULTADO')
fprintf(' Integral aproximada: I = %11.8f \n',Igauss2(k));
SOLUCIÓN
MÉTODO DE ROMBERG
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE ROMBERG
')
disp('================================================================
===')
syms ('x')
|METODOS NUMERICOS
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=1;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
k=1;
Ir(k,k)=(h/2)*sum(fx);
tol=1;
while tol>0.0001
N=2*N;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
Sp=length(fx);
k=k+1;
Ir(k,1)=(h/2)*(fx(1)+2*sum(fx(2:Sp-1))+fx(Sp));
for m=2:k
Ir(k,m)=(1/(4^(m-1)-1))*(4^(m-1)*Ir(k,m-1)-Ir(k-1,m-1));
end
tol=abs(Ir(k,m-1)-Ir(k,m));
end
Ir(m,k);
disp(' ')
disp(' RESULTADO')
fprintf(' Integral aproximada: I = %11.8f \n',Ir(m,k));
SOLUCIÓN
CONCLUSIÓN
Comparando los 5 metodos, podemos ver que todos nos dan una solución bastante similar,
pero la menos aproximada en este caso seria por el método del trapecio, luego la de Simpson
1/3, las restantes nos dan una solución técnicamente igual, pero para este ejercicio el mejor
|METODOS NUMERICOS
método seria el de cuadratura de gauss 2 puntos, acotando también los errores con los que
trabaja cada método, pero de todas maneras los 5 metodos empleados fueron eficientes.
MÉTODO DE ROMBERG
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=1;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
k=1;
tol=1;
while tol>0.0001
N=2*N;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
Sp=length(fx);
k=k+1;
for m=2:k
Ir(k,m)=(1/(4^(m-1)-1))*(4^(m-1)*Ir(k,m-1)-Ir(k-1,m-1));
end
end
Ir(m,k);
disp(' ')
disp(' RESULTADO')
|METODOS NUMERICOS
SOLUCIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=2;
H=(b-a)/(N/2);
R=[-1/sqrt(3) 1/sqrt(3)];
X=((b-a).*R+b+a)/2;
fx=F(X);
k=1;
tol=1;
c1=a;
c2=b;
while tol>0.0001
|METODOS NUMERICOS
N=2*N;
H=(c2-c1)/(N/2);
n=(a:H:b);
X=[];
for I=1:length(n)-1
c1=n(I);
c2=n(I+1);
X=[X ((c2-c1).*R+c2+c1)/2];
end
fx=F(X);
k=k+1;
end
Igauss2(k);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
|METODOS NUMERICOS
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=3;
H=(b-a)/N;
X=(a:H:b);
fx=F(X);
k=1;
Is3(k)=3*H/8*(fx(1)+3*fx(2)+3*fx(3)+4*fx(4));
tol=1;
while tol>0.0001
N=2*N;
H=(b-a)/N;
X=(a:H:b);
fx=F(X);
Sp=length(fx);
k=k+1;
1))+2*sum(fx(4:3:Sp-1))+fx(Sp));
end
Is3(k);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN:
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
|METODOS NUMERICOS

')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=2;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
k=1;
Is1(k)=(h/3)*(fx(1)+4*fx(2)+fx(3));
tol=1;
while tol>0.0001
N=2*N;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
Sp=length(fx);
k=k+1;
2))+fx(Sp));
end
Is1(k);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);
N=1;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
k=1;
tol=1;
while tol>0.0001
N=2*N;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
Sp=length(fx);
k=k+1;
end
Irt(k);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
|METODOS NUMERICOS
CONCLUSIÓN
trapecio y romberg nos dan casi la misma solución, pero la menos aproximada en este caso,
Simpson 3/8 da una solución similar pero que se aleja de los resultados en las ultimas cifras,
por lo tanto las mas efectivas seria Simpson 1/3 y cuadratura de gauss de 2 puntos, acotando
también los errores con los que trabaja cada método, pero de todas maneras los 5 metodos
empleados fueron bastante eficientes.
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
|METODOS NUMERICOS

c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);
N=1;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
k=1;
tol=1;
while tol>0.0001
N=2*N;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
Sp=length(fx);
k=k+1;
end
Irt(k);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
PSEUDOCÓDIGO
clc
|METODOS NUMERICOS
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=2;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
k=1;
Is1(k)=(h/3)*(fx(1)+4*fx(2)+fx(3));
tol=1;
while tol>0.0001
N=2*N;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
Sp=length(fx);
k=k+1;
2))+fx(Sp));
end
Is1(k);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=3;
H=(b-a)/N;
X=(a:H:b);
fx=F(X);
k=1;
Is3(k)=3*H/8*(fx(1)+3*fx(2)+3*fx(3)+4*fx(4));
tol=1;
while tol>0.0001
N=2*N;
H=(b-a)/N;
X=(a:H:b);
fx=F(X);
Sp=length(fx);
k=k+1;
1))+2*sum(fx(4:3:Sp-1))+fx(Sp));
end
Is3(k);
disp(' ')
disp(' RESULTADO')
|METODOS NUMERICOS
SOLUCIÓN:
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=2;
H=(b-a)/(N/2);
R=[-1/sqrt(3) 1/sqrt(3)];
X=((b-a).*R+b+a)/2;
fx=F(X);
k=1;
tol=1;
c1=a;
c2=b;
while tol>0.0001
N=2*N;
H=(c2-c1)/(N/2);
n=(a:H:b);
X=[];
|METODOS NUMERICOS
for I=1:length(n)-1
c1=n(I);
c2=n(I+1);
X=[X ((c2-c1).*R+c2+c1)/2];
end
fx=F(X);
k=k+1;
end
Igauss2(k);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
MÉTODO DE ROMBERG
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
|METODOS NUMERICOS
c=inline(s,'x');
F=vectorize(c);
a=ab(1);
b=ab(2);%%
N=1;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
k=1;
tol=1;
while tol>0.0001
N=2*N;
h=(b-a)/N;
x=a:h:b;
fx=F(x);
Sp=length(fx);
k=k+1;
for m=2:k
Ir(k,m)=(1/(4^(m-1)-1))*(4^(m-1)*Ir(k,m-1)-Ir(k-1,m-1));
end
end
Ir(m,k);
disp(' ')
disp(' RESULTADO')
SOLUCIÓN
|METODOS NUMERICOS
CONCLUSIÓN
trapecio y romberg nos dan una solución relativamente parecida, pero la menos
aproximada,en este caso, Simpson 1/3 da una solución similar pero que se aleja de los
resultados en las ultimas cifras, por lo tanto las mas efectivas seria Simpson 3/8 y cuadratura
de gauss de 2 puntos, acotando también los errores con los que trabaja cada método, pero de
todas maneras los 5 metodos empleados fueron bastante eficientes.
|METODOS NUMERICOS
ECUACIONES DIFERENCIALES ORDINARIAS (GERALD)
MÉTODO DE RUNGE KUTTA PARA EDO DE 2º ORDEN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE RUNGE KUTTA para EDO de 2do orden
')
disp('================================================================
===')
syms ('x')
s=input('\nf(t,y,dy) = ','s');
c=inline(s,'t','y','dy');
F=vectorize(c);
to=input('\nto = ');
yo=input('\nyo = ');
ypo=input('\ndyo = ');
fprintf('\nIngrese t para calcular y(t), dy(t):\n')
t=input('\nt = ');
N=30;
h=(t-to)/N;
y(1)=yo;
t(1)=to;
|METODOS NUMERICOS
yp(1)=ypo;
for I=2:N+1
k1=F(t(I-1),y(I-1),yp(I-1));
k2=F(t(I-1)+h/2,y(I-1)+h/2*yp(I-1)+h/8*k1,yp(I-1)+h/2*k1);
k3=F(t(I-1)+h/2,y(I-1)+h/2*yp(I-1)+h/8*k1,yp(I-1)+h/2*k2);
k4=F(t(I-1)+h,y(I-1)+h*yp(I-1)+h/2*k3,yp(I-1)+k3);
yp(I)=yp(I-1)+h/6*(k1+2*k2+2*k3+k4);
y(I)=y(I-1)+h*(yp(I-1)+h/6*(k1+k2+k3));
t(I)=t(I-1)+h;
end
iter=1:(N+1);
rpta=[iter' t' y' yp'];
disp(' ')
disp(' TABLA DE ITERACIONES ')
disp(' iter t y(t) dy(t)')
disp(rpta)
fprintf(' Solución aproximada:\n');
fprintf(' y(t) = %11.8f \n',y(N+1));
fprintf(' dy(t) = %11.8f \n',yp(N+1))
fprintf(' para t = %12.8f\n',t(N+1));
plot3(t,y,yp)
xlabel('t','Color','red')
ylabel('y(t)','Color','red')
zlabel('dy(t)','Color','red')
axis([t(1) t(N) min(y) max(y) min(yp) max(yp)])
grid on
SOLUCIÓN
|METODOS NUMERICOS
|METODOS NUMERICOS
CONCLUSIÓN
Este método es el mas efectivo por eso fue el empleado en este caso ya que es para segundo
orden, la solución que nos da es muy aproximada a la correcta, teniendo en cuenta el margen
de error.
MÉTODO DE RUNGE KUTTA
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE RUNGE KUTTA
')
disp('================================================================
===')
syms ('x')
s=input('\nf(t,y) = ','s');
c=inline(s,'t','y');
F=vectorize(c);
|METODOS NUMERICOS
fprintf('\nIngrese t para calcular y(t):\n')
t=input('\nt = ');
N=30;
h=(t-to)/N;
y(1)=yo;
t(1)=to;
for I=2:N+1
k1=F(t(I-1),y(I-1));
k2=F(t(I-1)+h/2,y(I-1)+h/2*k1);
k3=F(t(I-1)+h/2,y(I-1)+h/2*k2);
k4=F(t(I-1)+h,y(I-1)+h*k3);
y(I)=y(I-1)+h/6*(k1+2*k2+2*k3+k4);
t(I)=t(I-1)+h;
end
iter=1:(N+1);
rpta=[iter' t' y'];
disp(' ')
disp(' iter t y(t)')
disp(rpta)
fprintf(' Solución aproximada: y(t) = %11.8f \n',y(N+1));
plot(t,y)
axis([t(1) t(N) min(y) max(y)])
grid on
|METODOS NUMERICOS
SOLUCIÓN
|METODOS NUMERICOS
|METODOS NUMERICOS
MÉTODO DE EULER
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE EULER
')
disp('================================================================
===')
syms ('x')
F=vectorize(c);
t=input('\nt = ');
N=30;
h=(t-to)/N;
y(1)=yo;
t(1)=to;
for I=2:N+1
y(I)=y(I-1)+h*F(t(I-1),y(I-1));
t(I)=t(I-1)+h;
end
iter=1:(N+1);
rpta=[iter' t' y'];
disp(' ')
disp(rpta)
plot(t,y)
grid on
SOLUCIÓN
|METODOS NUMERICOS
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
F=vectorize(c);
t=input('\nt = ');
N=30;
h=(t-to)/N;
y(1)=yo;
t(1)=to;
for I=2:N+1
k1=F(t(I-1),y(I-1));
k2=F(t(I-1)+h/2,y(I-1)+h/2*k1);
k3=F(t(I-1)+h/2,y(I-1)+h/2*k2);
k4=F(t(I-1)+h,y(I-1)+h*k3);
y(I)=y(I-1)+h/6*(k1+2*k2+2*k3+k4);
t(I)=t(I-1)+h;
end
iter=1:(N+1);
|METODOS NUMERICOS
rpta=[iter' t' y'];

disp(' ')
disp(rpta)
plot(t,y)
grid on
|METODOS NUMERICOS
SOLUCIÓN
|METODOS NUMERICOS
|METODOS NUMERICOS
MÉTODO DE EULER
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
F=vectorize(c);
t=input('\nt = ');
N=30;
h=(t-to)/N;
y(1)=yo;
t(1)=to;
for I=2:N+1
y(I)=y(I-1)+h*F(t(I-1),y(I-1));
t(I)=t(I-1)+h;
end
iter=1:(N+1);
rpta=[iter' t' y'];
disp(' ')
disp(rpta)
plot(t,y)
grid on
|METODOS NUMERICOS
SOLUCIÓN
|METODOS NUMERICOS
CONCLUSIÓN
Comparando los 2 metodos, con diferentes puntos, podemos ver que ambos nos dan una
solución bastante similar, pero en este caso el método de Euler resulta mas efectivo,
considerando el margen de error, pero de todas maneras runge kutta resulta también muy
eficiente.
MÉTODO DE EULER
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
F=vectorize(c);
|METODOS NUMERICOS

t=input('\nt = ');
N=30;
h=(t-to)/N;
y(1)=yo;
t(1)=to;
for I=2:N+1
y(I)=y(I-1)+h*F(t(I-1),y(I-1));
t(I)=t(I-1)+h;
end
iter=1:(N+1);
rpta=[iter' t' y'];
disp(' ')
disp(rpta)
plot(t,y)
grid on
|METODOS NUMERICOS
SOLUCIÓN
|METODOS NUMERICOS
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
F=vectorize(c);
t=input('\nt = ');
N=30;
h=(t-to)/N;
y(1)=yo;
t(1)=to;
for I=2:N+1
k1=F(t(I-1),y(I-1));
k2=F(t(I-1)+h/2,y(I-1)+h/2*k1);
k3=F(t(I-1)+h/2,y(I-1)+h/2*k2);
k4=F(t(I-1)+h,y(I-1)+h*k3);
y(I)=y(I-1)+h/6*(k1+2*k2+2*k3+k4);
t(I)=t(I-1)+h;
end
iter=1:(N+1);
rpta=[iter' t' y'];
disp(' ')
disp(rpta)
plot(t,y)
grid on
SOLUCIÓN
|METODOS NUMERICOS
|METODOS NUMERICOS
CONCLUSIÓN
Comparando los 2 metodos, podemos ver que en este caso no nos dan una solución similar,
el método de Euler resulta ser mas efectivo, considerando el margen de error, pero de todas
maneras runge kutta resulta también muy eficiente.
ECUACIONES DIFERENCIALES PARCIALES (GERALD)
|METODOS NUMERICOS
MÉTODO CRANK NICOLSON
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO CRANK NICOLSON
')
disp('================================================================
===')
disp(' Método para resolver EDP parabólicas
')
disp('================================================================
===')
syms ('x')
fprintf('\nIngrese la condición inicial:\n')
s1=input('\ny(x,0) = ','s');
c1=inline(s1,'x');
Fx=vectorize(c1);
fprintf('\nIngrese las condiciones de frontera:\n')
s2=input('\ny(0,t) = ','s');
c2=inline(s2,'x');
G1t=vectorize(c2);
s3=input('\ny(L,t) = ','s');
c3=inline(s3,'x');
G2t=vectorize(c3);
fprintf('\nIngrese los tamaños de paso:\n')
DX=input('\ndx = ');
DT=input('\ndt = ');
fprintf('\nIngrese los valores finales:\n')
XF=input('\nx = ');
TF=input('\nt = ');
fprintf('\nIngrese el coeficiente de la 2da derivada parcial:\n')
alfa=input('\nalfa = ');
NX=XF/DX+1;
NT=TF/DT+1;
beta=alfa*DT/DX^2;
for I=2:NX-1
T(I)=Fx(DX*(I-1));
end
T(1)=(Fx(0)+G1t(0));
T(NX)=(Fx(XF)+G2t(0));
mat(1,:)=T(1:NX);
for I=1:NX-2
A(I)=beta;
B(I)=-2-2*beta;
C(I)=beta;
end
for I=1:NT-1
T(1)=G1t(DT*I);
T(NX)=G2t(DT*I);
for J=1:NX-2
D(J)=-beta*T(J)-(2-2*beta)*T(J+1)-beta*T(J+2);
end
D(1)=D(1)-beta*T(1);
D(NX-2)=D(NX-2)-beta*T(NX);
|METODOS NUMERICOS
V(1)=B(1);
for J=2:NX-2
V(J)=B(J)-(A(J)*C(J-1))/V(J-1);
end
W(1)=D(1)/V(1);
for J=2:NX-2
W(J)=(D(J)-A(J)*W(J-1))/V(J);
end
X(NX-2)=W(NX-2);
for J=1:NX-3
K=NX-2-J;
X(K)=W(K)-(C(K)*X(K+1))/V(K);
end
for J=1:NX-2
T(J+1)=X(J);
end
mat(I+1,:)=T(1:NX);
IT(I,1)=I*DT;
end
for I=1:NX-1
IX(I)=I*DX;
end
IT=[0;0;IT];
IX=[0 IX];
mat=[IT [IX;mat]];
disp(' ')
disp(' TABLA DE DISTRIBUCIÓN ')
disp(mat)
|METODOS NUMERICOS
SOLUCIÓN
|METODOS NUMERICOS
|METODOS NUMERICOS
CONCLUSIÓN
Este método de crank nicolson resulta ser muy eficiente para este tipo de ejercicios por eso
se eligio, ya que su solución es muy aproximada a la verdadera, y el margen de error es
considerablemente permisible, además se observa la cantidad de iteraciones que realiza.
Del libro de Burden y Faires
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
s1=input('\ny(x,0) = ','s');
c1=inline(s1,'x');
Fx=vectorize(c1);
s2=input('\ny(0,t) = ','s');
c2=inline(s2,'x');
G1t=vectorize(c2);
s3=input('\ny(L,t) = ','s');
c3=inline(s3,'x');
G2t=vectorize(c3);
XF=input('\nx = ');
TF=input('\nt = ');
NX=XF/DX+1;
NT=TF/DT+1;
beta=alfa*DT/DX^2;
for I=2:NX-1
T(I)=Fx(DX*(I-1));
end
T(1)=(Fx(0)+G1t(0));
mat(1,:)=T(1:NX);
for I=1:NX-2
A(I)=beta;
B(I)=-2-2*beta;
C(I)=beta;
end
for I=1:NT-1
T(1)=G1t(DT*I);
T(NX)=G2t(DT*I);
for J=1:NX-2
end
D(1)=D(1)-beta*T(1);
|METODOS NUMERICOS
V(1)=B(1);
for J=2:NX-2
V(J)=B(J)-(A(J)*C(J-1))/V(J-1);
end
W(1)=D(1)/V(1);
for J=2:NX-2
W(J)=(D(J)-A(J)*W(J-1))/V(J);
end
X(NX-2)=W(NX-2);
for J=1:NX-3
K=NX-2-J;
X(K)=W(K)-(C(K)*X(K+1))/V(K);
end
for J=1:NX-2
T(J+1)=X(J);
end
mat(I+1,:)=T(1:NX);
IT(I,1)=I*DT;
end
for I=1:NX-1
IX(I)=I*DX;
end
IT=[0;0;IT];
IX=[0 IX];
mat=[IT [IX;mat]];
disp(' ')
disp(mat)
|METODOS NUMERICOS
SOLUCIÓN
CONCLUSIÓN
En esta ocasión el método de crank nicolson no realiza tantas iteraciones debido a las
condiciones del problema, pero resulta ser muy eficiente para este tipo de ejercicios, ya que
su solución es muy aproximada a la verdadera, y el margen de error es considerablemente
permisible.
|METODOS NUMERICOS
Del libro de Burden y Faires
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')
')
disp('================================================================
===')
syms ('x')
s1=input('\ny(x,0) = ','s');
c1=inline(s1,'x');
Fx=vectorize(c1);
s2=input('\ny(0,t) = ','s');
c2=inline(s2,'x');
G1t=vectorize(c2);
s3=input('\ny(L,t) = ','s');
c3=inline(s3,'x');
G2t=vectorize(c3);
XF=input('\nx = ');
TF=input('\nt = ');
NX=XF/DX+1;
NT=TF/DT+1;
beta=alfa*DT/DX^2;
for I=2:NX-1
T(I)=Fx(DX*(I-1));
|METODOS NUMERICOS
end
T(1)=(Fx(0)+G1t(0));
mat(1,:)=T(1:NX);
for I=1:NX-2
A(I)=beta;
B(I)=-2-2*beta;
C(I)=beta;
end
for I=1:NT-1
T(1)=G1t(DT*I);
T(NX)=G2t(DT*I);
for J=1:NX-2
end
D(1)=D(1)-beta*T(1);
V(1)=B(1);
for J=2:NX-2
V(J)=B(J)-(A(J)*C(J-1))/V(J-1);
end
W(1)=D(1)/V(1);
for J=2:NX-2
W(J)=(D(J)-A(J)*W(J-1))/V(J);
end
X(NX-2)=W(NX-2);
for J=1:NX-3
K=NX-2-J;
X(K)=W(K)-(C(K)*X(K+1))/V(K);
end
for J=1:NX-2
T(J+1)=X(J);
end
mat(I+1,:)=T(1:NX);
IT(I,1)=I*DT;
end
for I=1:NX-1
IX(I)=I*DX;
end
IT=[0;0;IT];
IX=[0 IX];
mat=[IT [IX;mat]];
disp(' ')
disp(mat)
|METODOS NUMERICOS
SOLUCIÓN
CONCLUSIÓN
Este método de crank nicolson resulta ser muy eficiente para este tipo de ejercicios por eso
se eligio, y comparando con las condiciones y resultados del problema vemos que realmente
|METODOS NUMERICOS
se acerca mucho a la solución, el margen de error es considerablemente permisible, además se

observa la cantidad de iteraciones que realiza.
EIGEN VALORES (BURDEN Y FAIRES)
MÉTODO DE POTENCIACIÓN
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
disp(' MÉTODO DE POTENCIACIÓN
')
disp('================================================================
===')
fprintf('\nIngrese la matriz de datos:\n')

A=input('\nA = ');
Nc=length(A);
for I=1:Nc
[Ev Ld B]=Met_Potenciacion(A);
Valp(I)=Ld;
Vecp(:,I)=Ev;
A=B;
end
disp(' ')
disp(' VALORES PROPIOS')
disp(Valp)
disp(' VECTORES PROPIOS')
disp(Vecp)
|METODOS NUMERICOS
SOLUCIÓN
CONCLUSIÓN
El método de potenciación puede encontrar el eigenvalor más grande en valor absoluto y su

correspondiente eigenvector, es por eso que se eligio ya que nos da una solución bastante
aceptable, siendo el mas efectivo.
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')

A=input('\nA = ');
|METODOS NUMERICOS
Nc=length(A);
for I=1:Nc
Valp(I)=Ld;
Vecp(:,I)=Ev;
A=B;
end
disp(' ')
disp(Valp)
disp(Vecp)
SOLUCIÓN
CONCLUSIÓN
El método de potenciación, es un método iterativo que calcula sucesivas aproximaciones a

los autovectores y autovalores de una matriz. Este método se usa principalmente para
calcular el autovector de mayor autovalor en matrices grandes, es por eso que se eligio ya que
nos da una solución bastante aceptable, siendo el mas efectivo.
|METODOS NUMERICOS
PSEUDOCÓDIGO
clc
clear all
disp('================================================================
===')
')
disp('================================================================
===')

A=input('\nA = ');
Nc=length(A);
for I=1:Nc
Valp(I)=Ld;
Vecp(:,I)=Ev;
A=B;
end
disp(' ')
disp(Valp)
disp(Vecp)
|METODOS NUMERICOS
SOLUCIÓN
CONCLUSIÓN
El método de potenciación, es un método iterativo que calcula sucesivas aproximaciones a

los autovectores y autovalores de una matriz. Este método se usa principalmente para
calcular el autovector de mayor autovalor en matrices grandes.
Para aplicar el método de las potencias se supone que la matriz A de n x n tiene n valores
característicos con un conjunto asociado de vectores característicos
linealmente independientes . Es más, se supone que A tiene

exactamente un valor característico cuya magnitud es la mayor, por lo que
. El método converge lentamente, es por eso que se
eligio ya que nos da una solución bastante aceptable, siendo el mas efectivo.
|METODOS NUMERICOS
ANEXO
MATLAB (abreviatura de MATrix LABoratory, "laboratorio de matrices") es una herramienta de

software matemático que ofrece un entorno de desarrollo integrado (IDE) con un lenguaje de
programación propio (lenguaje M). Está disponible para las plataformas Unix, Windows, Mac
OS X y GNU/Linux .
Entre sus prestaciones básicas se hallan: la manipulación de matrices, la representación de
datos y funciones, la implementación de algoritmos, la creación de interfaces de usuario (GUI)
y la comunicación con programas en otroslenguajes y con otros dispositivos hardware. El
paquete MATLAB dispone de dos herramientas adicionales que expanden sus prestaciones, a
saber, Simulink (plataforma de simulación multidominio) y GUIDE (editor de interfaces de
usuario - GUI). Además, se pueden ampliar las capacidades de MATLAB con las cajas de
herramientas (toolboxes); y las de Simulink con los paquetes de bloques (blocksets).
Es un software muy usado en universidades y centros de investigación y desarrollo. En los
últimos años ha aumentado el número de prestaciones, como la de programar
directamente procesadores digitales de señal o crear código VHDL.
|METODOS NUMERICOS

Ejercicos Metodos Numericos Matlab

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ejercicos Metodos Numericos Matlab

Uploaded by

Copyright:

Available Formats

[UNSCH] INGENIERIA CIVIL

FACULTAD INGENIERÍA DE MINAS GEOLOGÍA Y CIVIL

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 1

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 2

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 3

Independientemente y casi simultáneamente Jean Joseph Leverrier (1811 – 1877) de París,

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 4

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 5

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 6

RESOLUCION DE EJERCICIOS DEL LIBRO “APPLIED NUMERICAL ANALYSYS- GERALD AND

TOMAMOS EJERCICIOS DEL LIBRO DE GERALD AND WHEATLEY

PRIMERO CON EL METODO BISECCION

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 7

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 8

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 9

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 10

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 11

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 12

MÉTODO DE LA FALSA POSICIÓN

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 13

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 14

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 15

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 16

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 17

MÉTODO NEWTON RAPHSON

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 18

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 19

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 20

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 21

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 22

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 23

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 24

METODO DE FALSA POSICIÓN

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 25

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 26

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 27

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 28

MÉTODO DE NEWTON RAPHSON

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 29

fprintf('\nIngrese la función en términos de x:\n')

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 30

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 31

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 32

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 33

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 34

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 35

MÉTODO DE LA FALSA POSICIÓN

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 36

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 37

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 38

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 39

MÉTODO DE NEWTON RAPHSON

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 40

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 41

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 42

SISTEMA DE ECUACIONES NO LINEALES

METODO DE NEWTON-RAPHSON PARA SISTEMAS DE ECUACIONES NO LINEALES

subtitle={'Ingrese las ecuaciones:'};

fprintf('\nIngrese los valores iniciales:\n')

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 43

while error>eps & k<31

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 44

El arte de calcular, que es distinto a la ciencia del cálculo, se basa en cálculos 45