Universidad de La Frontera

Departamento de Ingeniería Matemática.

Tarea 1: Análisis Numérico

Profesores: Juan Alfredo Gómez

Leonardo Villegas
Asignatura: Análisis numérico y
optimización/
Programación Matemática
Alumnos: Luis López
Freddy Muñoz
Fecha: 25 de septiembre 2017
 Introducción.

La definición de palabra es “conjunto de fonemas o letras que tienen un

significado”, lo cual se puede considerar “la unidad básica” del lenguaje, el cual, permite la
comunicación entre individuos.

En el área de la ciencia, el lenguaje universal es la matemática. Con ella se pueden

explicar cuantitativamente de índole teóricos y/o prácticos.

Dentro de la matemática existe una rama denominada análisis numérico, que se

desempeña en el diseño y construcción de algoritmos utilizando de reglas matemáticas
simples para modelar procesos más complejos.

El análisis numérico tiene una importancia crucial en materia de ordenadores,

debido a sus limitaciones de estos.

A continuación se presentaran una serie de ejercicios de análisis numérico en los

que se verán temas como análisis de error, y resolución de ecuaciones y sistemas de
ecuaciones por medio de aproximaciones obtenidas empleando distintos métodos
numéricos.
 Errores y Aproximaciones
La representación de un valor exacto, es lo que se denomina aproximación, y esta
será mejor mientras más se acerque al número exacto.

Dos formas de aproximar son:

 Corte: Consiste en cortar la mantisa de un número sin aproximar el último digito,
en las cifras que sean necesarias. Por ejemplo, cortar el siguiente número 2.4567 en
dos decimales seria 2.4567 ̴ 2.45
 Redondeo: consiste en cortar la mantisa, pero esta vez sí se debe aproximar, para
eso, se debe observar el primer número que ya no formara parte de la mantisa, si
este es mayor o igual a 5, se debe sumar una unida al último número de la nueva
mantisa. Por ejemplo, redondear el número 2.4567 a dos decimales seria 2.4567 ̴
2.46.

Debido el limitado espacio de los computadores y a las aproximaciones se provocan

errores en los resultados. Estos errores pueden ser:
 Error de truncamiento: se provoca al utilizar aproximaciones o serie de ellas
 Error de aproximación: sinónimo de limitaciones computacionales.

Ecuaciones no lineales

Una ecuación no lineal son aquellas ecuaciones a las cuales no admiten el principio
superposición.
 Desarrollo
1.- Errores y Aproximación de funciones
1.1.- Sea el siguiente sistema de ecuaciones lineales:

Donde h = 2 ± 0,03; k = t − h y t = 2/h. ¿Con qué exactitud se puede determinar el producto

x 1 x 2 ? (usar la formula de propagación del error absoluto).

Solución:
Lo primero es desarrollar dejar k y t en términos de h

2 2
𝑘= −ℎ ; 𝑡=
ℎ ℎ

Se despejó X1 y X2 en función de h
25 ℎ2 4 ℎ
𝑥1 = − ; 𝑥2 = −
3 6 3ℎ 6

Se calcularon las derivadas

ℎ −4 1
𝑥1′ = − ; 𝑥2 ′ = −
3 3ℎ2 6

El código empleado es el siguiente:

clear all;
clc;
h=2;

error=0.03;
x1=-h/3;
x2=-4/(3*h^-2)+1/6;
exactitud=abs(x1*error+x2*error)

Finalmente, el resultado es:

Exactitud = 0.1750

2.- Ecuaciones No lineales

2.1.- Resuelva la siguiente ecuación, utilizando el método de punto fijo:
Encuentre el valor de t del problema anterior, si el punto inicial es t 0 = 10, además el error
cometido debe ser menor que 10^−5 . En el informe deberá incluir la cantidad de
iteraciones y la solución obtenida en cada iteración.

Solución:
Despeje 1 (línea 18) Despeje 2 (línea 19)

El código desarrollado es el siguiente:

clear all;
clc;

%parametros
xiv=10;
tol=10^-5;
nmax=10;

n=1;
i=1;
j=1;

for n=1:1:nmax
Tab(i,j)=n-1;
j=j+1;
Tab(i,j)=xiv;
j=j+1;
Tab(i,j)=((0.4^1.95)/((4*log(6000*(xiv^0.8))*0.4^1.2)-0.4^1.75));
%Tab(i,j)=((exp((0.4^0.75/4)*((1/xiv)+(0.4/0.4^1.2))))/6000)^(1/0.8);
xin=Tab(i,j);
j=j+1;
if i==1
Tab(i,j)=0;
else
Tab(i,j)=abs(Tab(i-1,j-2)-xin);
if Tab(i,j)<tol
break
end
end
xiv=xin;
i=i+1;
j=1;
end
textos={'iteracion','xi','f(xi)','error'};
textos=[textos;num2cell(Tab)]
para el primer despeje la tabla resultado es la siguiente:

Para el otro despeje la tabla es la siguiente:

Se observa que en el segundo despeje no es posible encontrar un valor real de aproximación

debido a que Euler para ningún valor es 0.
La línea 18 y 19 contienen ambos despejes. Para visualizar uno hay que manipular los
comentarios.

2.2.- Dada la ecuación:

a) Programar y usar el método de la Falsa Posición para aproximar la raíz de la ecuación, en

el intervalo [1 2] con un error menor de 10^−10 . Comente que ocurre si la cantidad
máxima de iteraciones es 5.

b) Programar y usar el método de de la secante en el mismo intervalo anterior para hallar

una raíz aproximada, hasta que el valor de |x(i) − x(i−1) | ≤ 10^−5 , tomando como x0 =
−2,4 y x1 = −1,6.

Solución:
a) El código desarrollado es el siguiente:
clear all;
clc;

%parametros
a=1;
b=2;
tol=10^-10;
nmax=5;

fx=inline('(1/5)+((log(x))/2)-exp(-x)');
A=fx(a);
B=fx(b);
if A*B<0
n=1;
i=1;
j=1;
for n=1:1:nmax+1
Tab(i,j)=n-1;
j=j+1;
Tab(i,j)=a;
j=j+1;
Tab(i,j)=b;
j=j+1;
Tab(i,j)=A;
j=j+1;
Tab(i,j)=B;
j=j+1;
Tab(i,j)=((a*B-b*A)/(B-A));
xi=Tab(i,j);
j=j+1;
Tab(i,j)=fx(xi);
j=j+1;
if i==1
Tab(i,j)=0;
else
Tab(i,j)=abs(Tab(i-1,j-2)-xi);
if Tab(i,j)<tol
break
end
end
if Tab(i,j-1)*A>0
a=xi;
A=Tab(i,j-1);
else
b=xi;
B=Tab(i,j-1);
end
i=i+1;
j=1;
end
else
disp('no se puede emplear el metodo de falsa posicion en ese intervalo')
end
textos={'iteracion','a','b','f(a)','f(b)','xi','f(xi)','error'};
textos=[textos;num2cell(Tab)]

La tabla con 5 iteraciones en la siguiente

Si damos más iteraciones, por ejemplo 50, se cumple primero la condición de error antes
que la cantidad de iteraciones por lo que termina antes, finalmente en 10 iteraciones se
cumple la tolerancia.

La tabla resultado es la siguiente:

b) El código desarrollado es el siguiente:

clear all;
clc;

%parametros
x0=1;
x1=2;
tol=10^-10;
nmax=50;

fx=inline('(1/5)+((log(x))/2)-exp(-x)');

fx0=fx(x0);
fx1=fx(x1);

n=1;
i=1;
j=1;
for n=1:1:nmax+1
Tab(i,j)=n-1;
j=j+1;
Tab(i,j)=x0;
j=j+1;
Tab(i,j)=x1;
j=j+1;
Tab(i,j)=fx0;
j=j+1;
Tab(i,j)=fx1;
j=j+1;
Tab(i,j)=x1-(((x1-x0)*Tab(i,j-1))/(Tab(i,j-1)-Tab(i,j-2)));
xi=Tab(i,j);
j=j+1;
Tab(i,j)=fx(xi);
j=j+1;
if i==1
Tab(i,j)=0;
else
Tab(i,j)=abs(Tab(i-1,j-2)-xi);
 if Tab(i,j)<=tol
break
end
end
x0=x1;
fx0=fx(x0);
x1=xi;
fx1=fx(x1);
i=i+1;
j=1;
end
textos={'iteracion','x0','x1','f(x0)','f(x1)','xi','f(xi)','error'};
textos=[textos;num2cell(Tab)]

La tabla de resultados es la siguiente:

2.3.- Considere el sistema:

Resuelva el sistema de ecuaciones usando el método de Newton en tres dimensiones,

teniendo en cuenta las siguientes condiciones: el punto inicial es (x,y,z)t = (4,−1,−13), la
tolerancia será de 10^−5 , como máximo 100 iteraciones y en el error debe considerar la
norma 2. Comente sus resultados e indique que ocurre si el punto inicial es el (x,y,z)t =
(0,0,0)

Solución:
El código desarrollado es el siguiente:
clear all;
clc;

%funciones
f1=inline('x^2-2*x-z+0.5');
f2=inline('x^2+4*y^2+z^2-4');
f3=inline('-x^2+y^2+z');

%condiciones
nmax=100;
tol=10e-5;

%jacobiano
j11=inline('2*x - 2');
j12=0;
j13=-1;
j21=inline('2*x');
j22=inline('8*y');
j23=inline('2*z');
j31=inline('-2*x');
j32=inline('2*y');
j33=1;

%punto inicial 4,-1,-13

pk=[4;-1;-13];

Tab(1,1)=0;
Tab(1,2)=pk(1);
Tab(1,3)=pk(2);
Tab(1,4)=pk(3);
Tab(1,5)=f1(pk(1),pk(3));
Tab(1,6)=f2(pk(1),pk(2),pk(3));
Tab(1,7)=f3(pk(1),pk(2),pk(3));

flag=0;
for i=2:nmax%iteraciones
if det([j11(pk(1)),j12,j13;j21(pk(1)),j22(pk(2)),j23(pk(3));j31(pk(1)),j32(pk(2)),j33])==0
pk
disp('no hay solucion');
flag=1;
break;
else
fpk=[f1(pk(1),pk(3));f2(pk(1),pk(2),pk(3));f3(pk(1),pk(2),pk(3))];
delta=inv([j11(pk(1)),j12,j13;j21(pk(1)),j22(pk(2)),j23(pk(3));j31(pk(1)),j32(pk(2)),j33])*fpk;
pk1=pk-delta;
Tab(i,1)=i-1;
Tab(i,2)=pk1(1);
Tab(i,3)=pk1(2);
Tab(i,4)=pk1(3);
Tab(i,5)=f1(pk1(1),pk1(3));
Tab(i,6)=f2(pk1(1),pk1(2),pk1(3));
Tab(i,7)=f3(pk1(1),pk1(2),pk1(3));
Tab(i,8)=sqrt(delta(1)^2+delta(2)^2+delta(3)^2);
pk=pk1;

if tol>Tab(i,8)
break;
end
end
end

if flag==0
pk
textos={'iteracion','x','y','z','f1(x)','f2(y)','f3(z)','error'};
textos=[textos;num2cell(Tab)]
end

%punto inicial 0,0,0

pk=[0;0;0];

Tab(1,1)=0;
Tab(1,2)=pk(1);
Tab(1,3)=pk(2);
Tab(1,4)=pk(3);
Tab(1,5)=f1(pk(1),pk(3));
Tab(1,6)=f2(pk(1),pk(2),pk(3));
Tab(1,7)=f3(pk(1),pk(2),pk(3));

flag=0;
for i=2:nmax%iteraciones
if det([j11(pk(1)),j12,j13;j21(pk(1)),j22(pk(2)),j23(pk(3));j31(pk(1)),j32(pk(2)),j33])==0
pk
disp('no hay solucion');
flag=1;
break;
else
fpk=[f1(pk(1),pk(3));f2(pk(1),pk(2),pk(3));f3(pk(1),pk(2),pk(3))];
delta=inv([j11(pk(1)),j12,j13;j21(pk(1)),j22(pk(2)),j23(pk(3));j31(pk(1)),j32(pk(2)),j33])*fpk;
pk1=pk-delta;
Tab(i,1)=i-1;
Tab(i,2)=pk1(1);
Tab(i,3)=pk1(2);
Tab(i,4)=pk1(3);
Tab(i,5)=f1(pk1(1),pk1(3));
Tab(i,6)=f2(pk1(1),pk1(2),pk1(3));
Tab(i,7)=f3(pk1(1),pk1(2),pk1(3));
Tab(i,8)=sqrt(delta(1)^2+delta(2)^2+delta(3)^2);
pk=pk1;

if tol>Tab(i,8)
break;
end
end
end

if flag==0
pk
textos={'iteracion','x','y','z','f1(x)','f2(y)','f3(z)','error'};
textos=[textos;num2cell(Tab)]
end

La tabla con los resultados es la siguiente:

Para el caso de utilizar el punto origen (0,0,0) el programa nos arroja el mensaje:

2.4.- Considere el siguiente sistema AnX = bn , donde An y bn estan definidos por:

a) Programe la matriz An (An es una matriz que pertenece a R(nxn)) y el vector bn ,

además deberá truncar la matriz con 2 decimales.

b) Programe una rutina que resuelva el sistema Ax = b usando la descomposición plu de

MATLAB y las sustitución hacia adelante y hacia atrás.

c) Programe una rutina que resuelva el sistema Ax = b usando la eliminación de Gauss.

d) Considere el valor de n=10 para la resolución de los incisos anteriores.

e) En el informe debe mostrar las matrices que descoponen A de la forma A = P^−1 LU y

la matriz final del método de eliminación de Gauss, además de las soluciones encontrada en
cada inciso.

Solución:
a) El código desarrollado es el siguiente:
clear all;
clc;

n=10;

decimales=2;

bn=[];
for i=1:n
for j=1:n
if i==j
An(i,j)=round((i+j)^2/j,decimales);
else
An(i,j)=round((-1)^(i+j)*(i/j+j/i),decimales);
end
end
bn=[bn;round((-1)^i*mod(i^5-i^2+5*i+4,i^2+1),decimales)];
end

An
bn
b) El código desarrollado es el siguiente:
[L,U,P] = lu(An);
X3=P*bn;
X2=inv(L)*X3;
sol=inv(U)*X2

c) En este caso construimos la función gauss y la usamos

[m,sol]=gauss([An,bn])

El código de la función es el siguiente:

function [m,x]=gauss(m);

rows=size(m,1);
columns=size(m,2);

if columns==rows+1
n=rows;
%1
for i=1:n-1
%2
for k=i:n
if m(k,i)==0 & k>=i
%disp('No hay solucion unica');
break;
end
end
%3
if m(i,i)==0
p=i;
while m(p,i)==0 & p>=i
p=p+1;
end
%fprintf('fila%d <--> fila%d\n',i,p);
m=permutar(m,p,i);
end
%4
for j=i+1:n
if m(i,i)~=0
t=m(j,i)/m(i,i);
m(j,:)=m(j,:)-t*m(i,:);
%fprintf('fila%d-(%d)*fila%d\n',j,t,i);
end
end
end
%5
if m(n,n)==0
%disp('No hay solucion unica');
else
%6
x=[];
for i=1:n
x=[x;0];
end
 x(n)=m(n,n+1)/m(n,n);

%7
for i=n-1:-1:1
suma=0;
for j=i+1:n
suma=m(i,j)*x(j)+suma;
end
x(i)=(m(i,n+1)-suma)/m(i,i);
end
end
else
fprintf('Matriz no cuadrada\n');
end

d) Teniendo como n=10 la matriz generada es la siguiente:

a)

b) Usando descomposición PLU de MATLAB con sustitución adelante y atrás

obtenemos los siguientes resultados
Las soluciones obtenidas son:

c) Por Gauss obtenemos la siguiente matriz superior:

sus soluciones por eliminación son:

 Conclusiones
Un programa es una es una lista de instrucciones por medio de las que el ordenador
puede modelar matemáticamente procesos de la realidad.

El correcto orden de instrucciones y una buena sintaxis son cruciales para no

cometer errores de programación.

Debido a las aproximaciones y las limitaciones del ordenador los resultados siempre
presentaran errores tanto de truncamiento como de aproximaciones por la base usada o por
definición (por ejemplo el numero π)