Resolución Numérica de Sistemas de Ecuaciones
Clasificado en Matemáticas
Escrito el en 
español con un tamaño de 5,12 KB
Gauss-Jacobi
Método de Gauss-Jacobi
Este es un método iterativo para resolver sistemas de ecuaciones lineales.
Entrada de datos
Se solicitan el número de ecuaciones, los valores de la matriz A, el vector B y un vector inicial para la iteración.
n=input('número de ecuaciones: ');
display('Cargue los valores de la matriz A:')
for i=[1:n]
for j=[1:n]
printf('A(%.0f,%.0f): ',i,j)
A(i,j)=input('');
end
end
display('Cargue los valores del vector B:')
for i=[1:n]
printf('B(%.0f): ',i)
B(i,1)=input('');
end
display('Cargue los valores del vector inicial:')
k=1;
for i=[1:n]
printf('X(%.0f): ',i)
X(i,k)=input('');
end
display('Especifique un valor de tolerancia:')
tol=input('tol: ');
Cálculos
El proceso iterativo continúa hasta que la diferencia entre iteraciones sucesivas sea menor que la tolerancia especificada.
do
difc=0;
for i=[1:n]
suma=0;
for j=[1:n]
if j~=i
suma=suma+A(i,j)*X(j,k);
end
end
X(i,k+1)=(B(i,1)-suma)/A(i,i);
difc=difc+(X(i,k+1)-X(i,k))^2;
end
k=k+1;
until sqrt(difc)
Salida de resultados
Se muestra la solución del sistema encontrada y el número de iteraciones realizadas.
display('La solución del sistema es:')
display(X(:,k))
printf('Se realizaron %.0f iteraciones\n',k)
Factorización L*U
Solución de sistemas de ecuaciones lineales por factorización L-U
Este es un método directo para resolver sistemas de ecuaciones lineales.
clear
Datos iniciales
Se solicitan el número de ecuaciones, los valores de la matriz A y el vector B.
n=input('número de ecuaciones: ');
display('Cargue los valores de la matriz A:')
for i=[1:n]
for j=[1:n]
printf('A(%.0f,%.0f): ',i,j)
A(i,j)=input('');
end
end
display('Cargue los valores del vector B:')
for i=[1:n]
printf('B(%.0f): ',i)
B(i,1)=input('');
end
Factorización de A en L-U
La matriz A se descompone en una matriz triangular inferior L y una matriz triangular superior U.
[L,U]=lu(A);
Solución de subsistemas
Se plantean los subsistemas L*Y=B y U*X=Y, que se resuelven mediante sustitución hacia adelante y sustitución hacia atrás, respectivamente.
Solución de L*Y=B mediante sustitución hacia adelante
for i=[1:n]
suma=0;
for j=[1:i-1]
suma=suma+L(i,j)*Y(j,1);
end
Y(i,1)=B(i,1)-suma;
end
Solución de U*X=Y mediante sustitución hacia atrás
for k=[0:n-1]
suma=0;
for j=[n-k+1:n]
suma=suma+U(n-k,j)*X(j,1);
end
X(n-k,1)=(Y(n-k,1)-suma)/U(n-k,n-k);
end
Salida de resultados
Se muestra la solución del sistema encontrada.
display('La solución del sistema es:')
display(X)
Sistema No Lineal – Método de Newton
Método de Newton para Sistemas No Lineales
Este es un método iterativo para encontrar las raíces de un sistema de ecuaciones no lineales.
Carga de datos iniciales
Se solicitan valores iniciales para las variables y un valor de tolerancia para la convergencia.
i=1;
display('Valores iniciales de x e y:')
x(i)=input('x(1): ');
y(i)=input('y(1): ');
display('Asigne un valor de tolerancia')
tol=input('tol: ');
Cálculos
El método utiliza las derivadas parciales de las funciones (implícitamente formando la matriz Jacobiana) para iterar hacia la solución. El proceso continúa hasta que la magnitud del paso de corrección sea menor que la tolerancia.
do
f=4-x(i)^2-y(i)^2;
g=1-exp(x(i))-y(i);
dfx=-2*x(i);
dfy=-2*y(i);
dgx=-exp(x(i));
dgy=-1;
dx=(-f*dgy+g*dfy)/(dfx*dgy-dgx*dfy);
dy=(-dfy*g+dgx*f)/(dfx*dgy-dgx*dfy);
x(i+1)=x(i)+dx;
y(i+1)=y(i)+dy;
i=i+1;
until sqrt(dx^2+dy^2)
xr=x(i);
yr=y(i);
fs=f;
gs=g;
Salida de resultados
Se muestra el punto aproximado de la solución, los valores de las funciones en ese punto y el número de iteraciones realizadas.
printf('La solución se aproxima al punto (%.5f;%.5f)\nlas funciones alcanzan los valores f=%.5f y g=%.5f\nse realizaron %.0f iteraciones\n',xr,yr,fs,gs,i)