Documente Academic
Documente Profesional
Documente Cultură
MÉTODOS NUMÉRICOS
“MÉTODO DE BISECCIÓN”
GRUPO: 2SM1
Este método consiste en dividir sucesivamente el intervalo [a, b], por la mitad, hasta
que la longitud del subintervalo que contiene a la raíz α sea menor que alguna
tolerancia especificada ε.
VENTAJAS:
– Siempre converge.
– Útil como aproximación inicial de otros métodos.
DESVENTAJAS:
no
2.- Dividir el intervalo en dos partes iguales reteniendo la mitad en donde f(x) cambia
de signo, para conservar al menos una raíz.
3.- Repetir el proceso varias veces hasta cumplir con la tolerancia deseada.
si:
f(m) f(b)<0 entonces conservar (m, b) como el semi intervalo que contiene al
menos una raíz.
A cada paso se le llama “iteración” y reduce el intervalo a la mitad.
𝑖=1
𝑋𝑙 = 0.5 𝑋𝑢 = 1
𝑓(𝑋𝑙)𝑓(𝑋𝑢) < 0
𝑓(𝑋𝑙) = 𝑓(0.5) = −1.21
𝑓(𝑋𝑢) = 𝑓(1.0) = 5
𝑓(−1.21)𝑓(5) = −6.05
𝑃𝑜𝑟 𝑙𝑜 𝑡𝑎𝑛𝑡𝑜 𝑒𝑥𝑖𝑠𝑡𝑒 𝑎𝑙 𝑚𝑒𝑛𝑜𝑠 𝑢𝑛𝑎 𝑟𝑎í𝑧 𝑒𝑛 𝑒𝑙 𝑖𝑛𝑡𝑒𝑟𝑣𝑎𝑙𝑜 𝑑𝑎𝑑𝑜
𝑋𝑙 + 𝑋𝑢 0.5 + 1
𝑋𝑟 = = = 0.75
2 2
0.75 − 0
𝜀𝑎1 = │ │ ∗ 100% = 100%
0.75
𝑖=2
𝑋𝑙 = 0.5 𝑋𝑢 = 0.75
𝑋𝑙 + 𝑋𝑢 0.5 + 0.75
𝑋𝑟 = = = 0.625
2 2
0.625 − 0.75
𝜀𝑎2 = │ │ ∗ 100% = 20%
0.625
𝑖=3
𝑋𝑙 = 0.5 𝑋𝑢 = 0.625
𝑋𝑙 + 𝑋𝑢 0.5 + 0.625
𝑋𝑟 = = = 0.5625
2 2
0.5625 − 0.625
𝜀𝑎3 = │ │ ∗ 100% = 11.11%
0.5625
𝑖=4
𝑋𝑙 = 0.5 𝑋𝑢 = 0.5625
𝑋𝑙 + 𝑋𝑢 0.5 + 0.5625
𝑋𝑟 = = = 0.53125
2 2
0.53125 − 0.5625
𝜀𝑎4 = │ │ ∗ 100% = 5.88%
0.53125
Iteración 𝑿𝒍 𝑿𝒖 𝑿𝒓 𝜺𝒂 (%)
1 0.5 1.0 0.75 100
2 0.5 0.75 0.625 20
3 0.5 0.625 0.5625 11.11
4 0.5 0.5625 0.53125 5.88
ALGORITMO
1) Elija valores iniciales inferiores (Xl) y superiores (Xu) que encierren la raíz.
Tal que f(Xl)∙f(Xu) < 0
𝑋𝑙 + 𝑋𝑢
𝑋𝑟 = 2
3) Realice las siguientes evaluaciones para determinar en que subintervalo está
la raíz.
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
int main ()
{
//DECLARACIÓN DE VARIABLES
double Xl,Xu,Es,FXl=0.0,FXu=0.0, Xrant=0.0,Xr=0.0,FXr=0.0,Ea=0.0;
int i=1;
//LEE Xl, Xu y Es
printf ("\nIngrese el valor del intervalo inferior: ");scanf ("%lf",&Xl);
printf ("\nIngrese el valor del intervalo superior: ");scanf ("%lf",&Xu);
printf ("\nIngrese el error estimado para el calculo de la raiz: ") ;
scanf("%lf",&Es);
//EVALUACIÓN DE LA FUNCIÓN
FXl= -26 + 85*Xl - 91*pow(Xl,2) + 44*pow(Xl,3) - 8*pow(Xl,4) + pow(Xl,5);
FXu= -26 + 85*Xu - 91*pow(Xu,2) + 44*pow(Xu,3) - 8*pow(Xu,4) + pow(Xu,5);
//MUESTRA DE RESULTADOS
printf("\t %0.6lf \t %.6lf \n", Xr, Ea);
i=i+1;//CONTADOR PARA LAS ITERACIONES
}
while (Es<Ea); //CONDICIÓN DE PARO PARA EL PROCESO ITERATIVO
}
return 0;
}
RESULTADOS
Se dan a conocer los resultados a través de una tabla que contiene el número de
iteraciones, los intervalos inferiores(Xl) y superiores (Xu) en cada iteración, así como su
correspondiente porcentaje de error aproximado. Por último, se muestra en pantalla el
resultado a la aproximación de la raíz con su respectivo error aproximado (inferior o igual
al error estimado).
CONCLUSIONES
Según los resultados obtenidos mediante la programación y los realizados
manualmente, se concluye que el método de bisección al ser un método cerrado
siempre va a converger dando una solución al sistema propuesto, esta solución será
cada vez más aproximada a la raíz verdadera dependiendo del número de iteraciones,
es decir, entre más iteraciones mejores resultados.
En lo que respecta al trabajo manual para resolución de problemas con este método,
se puede decir que conlleva relativamente mucho tiempo por lo que la programación
ayuda mucho a una mejor eficiencia en cuestión de ahorro de tiempo, aparte de que
es un código sencillo de programar.
Ramírez Ramos Jocelyn Marie.
MÉTODOS NUMÉRICOS
“MÉTODO DE LA TANGENTE”
GRUPO: 2SM1
2. Será capaz de identificar los problemas que se pueden solucionar por dicho
método y a los que se deberá aplicar otro método.
x 100 %
El método de Newton-Raphson es convergente cuadráticamente, es decir, el error
es aproximadamente al cuadrado del error anterior.
Esto significa que el número de cifras decimales correctas se duplica
aproximadamente en cada interacción.
Cuando el método de Newton-Raphson converge, se obtienen resultados en
relativamente pocas interacciones, ya que para raíces no repetidas este método
converge con orden 2 y el error Ei+1 es proporcional al cuadrado del resultado
anterior Ei
Supóngase que el error en una iteración es 10 -n el error en la siguiente, (que es
proporcional al cuadrado del error anterior) es entonces aproximadamente 10-2n, el
que sigue será aproximadamente 10-4n etc.
De esto puede afirmarse que de cada iteración duplica aproximadamente el número
de dígitos correctos.
Sin embargo, el método de Newton-Raphson algunas veces no converge, sino que
oscila. Esto ocurre si no hay raíz real, si la raíz es un punto de inflexión o si el valor
inicial está muy alejado de la raíz buscada y alguna otra parte de la función “atrapa”
la iteración. (3)
Desventajas del Método de Newton-Raphson:
- Lenta convergencia debida a la naturaleza de una función en particular.
- Cuando un punto de inflexión, f’’(x) = 0, ocurre en la vecindad de una raíz.
- No existe un criterio general de convergencia.
- Evaluación de la derivada.
SISTEMA A RESOLVER:
Utilice el método de Newton-Raphson para calcular la raíz de 𝑓(𝑥) = 𝑒 −𝑥 − 𝑥
empleando como valor inicial 𝑥𝑜 = 0.
𝒊=𝟎
𝒇(𝒙𝟎 ) = 𝟏
𝒇′ (𝒙𝟎 ) = −𝟐
𝒇(𝒙𝟎 ) 𝟏
𝒙𝟏 = 𝒙𝟎 − ′
= 𝟎 + = 𝟎. 𝟓
𝒇 (𝒙𝟎 ) 𝟐
𝒙𝟏 − 𝒙𝟎 𝟎. 𝟓 − 𝟎
𝝐𝒂 = | | × 𝟏𝟎𝟎 = | | × 𝟏𝟎𝟎 = 𝟏𝟎𝟎%
𝒙𝟏 𝟎. 𝟓
𝒊=𝟏
𝒇(𝒙𝟏 ) = 𝟎. 𝟏𝟎𝟔𝟓
𝒇′ (𝒙𝟏 ) = −𝟏. 𝟔
𝒇(𝒙𝟏 ) 𝟎. 𝟏𝟎𝟔𝟓
𝒙𝟐 = 𝒙𝟏 − ′
= 𝟎. 𝟓 + = 𝟎. 𝟓𝟔𝟔𝟓𝟔𝟐
𝒇 (𝒙𝟏 ) −𝟏. 𝟔
𝒙𝟐 − 𝒙𝟏 𝟎. 𝟓𝟔𝟔𝟓𝟔𝟐 − 𝟎. 𝟓
𝝐𝒂 = | | × 𝟏𝟎𝟎 = | | × 𝟏𝟎𝟎 = 𝟏𝟏. 𝟓𝟒%
𝒙𝟐 𝟎. 𝟓𝟔𝟔𝟓𝟔𝟐
𝒊=𝟐
𝒇(𝒙𝟐 ) = 𝟎. 𝟎𝟎𝟎𝟗𝟏𝟏
𝒇′ (𝒙𝟐 ) = −𝟏. 𝟓𝟔
𝒇(𝒙𝟐 ) 𝟎. 𝟎𝟎𝟎𝟗𝟏𝟏
𝒙𝟑 = 𝒙𝟐 − ′
= 𝟎. 𝟓𝟔𝟔𝟓𝟔𝟐 − = 𝟎. 𝟓𝟔𝟕𝟏𝟒𝟔
𝒇 (𝒙𝟐 ) −𝟏. 𝟓𝟔
𝒙𝟑 − 𝒙𝟐 𝟎. 𝟓𝟔𝟕𝟏𝟒𝟔 − 𝟎. 𝟓𝟔𝟔𝟓𝟔𝟐
𝝐𝒂 = | | × 𝟏𝟎𝟎 = | | × 𝟏𝟎𝟎 = 𝟎. 𝟏%
𝒙𝟑 𝟎. 𝟓𝟔𝟕𝟏𝟒𝟔
𝒊=𝟑
𝒇(𝒙𝟑 ) = −𝟎. 𝟎𝟎𝟎𝟎𝟎𝟒
𝒇′ (𝒙𝟑 ) = −𝟏. 𝟓𝟔
𝒊=𝟒
𝒇(𝒙𝟒 ) = 𝟎. 𝟎𝟎𝟎𝟎𝟎𝟎
𝒇′ (𝒙𝟒 ) = −𝟏. 𝟓𝟔
𝒇(𝒙𝟒 ) 𝟎. 𝟎𝟎𝟎𝟎𝟎𝟎
𝒙𝟓 = 𝒙𝟒 − ′
= 𝟎. 𝟓𝟔𝟕𝟏𝟒𝟑 − = 𝟎. 𝟓𝟔𝟕𝟏𝟒𝟑
𝒇 (𝒙𝟒 ) −𝟏. 𝟓𝟔
𝒙𝟓 − 𝒙𝟒 𝟎. 𝟓𝟔𝟕𝟏𝟒𝟑 − 𝟎. 𝟓𝟔𝟕𝟏𝟒𝟑
𝝐𝒂 = | | × 𝟏𝟎𝟎 = | | × 𝟏𝟎𝟎 = 𝟎. 𝟎%
𝒙𝟓 𝟎. 𝟓𝟔𝟕𝟏𝟒𝟑
𝑓(𝑥) = 𝑒 −𝑥 − 𝑥
𝒊 𝑿𝒊 𝑿𝒊+𝟏 ∈𝒂 (%)
0 0 0.5 100
1 0.5 0.566311 11.74
2 0.566311 0.567146 0.14
3 0.567146 0.567143 0.0005
4 0.567143 0.557143 0
ALGORITMO
1. Elija un número inicial x0.
2. Calcular f (xi) y f’ (xi) y sustituirlos en la ecuación de NEWTON-RAPHSON
𝑓(𝑥𝑖 )
𝑥𝑖+1 = 𝑥𝑖 −
𝑓′(𝑥𝑖 )
Se puede considerar que este método es de los más efectivos para aplicarlos
en la programación pues su código es más simple que el del método de
bisección.
MÉTODOS NUMÉRICOS
MÉTODO DE LA SECANTE
Docente:
Manuel Torres Sabino
Integrantes de Equipo:
Gutiérrez Rosales Germán
Amaro Sánchez Ricardo Daniel
Ramírez Ramos Jocelyn Marie
Grupo: 2SM1
(1)
(2)
Figure: Representación geométrica del
método de la secante.
𝟐
𝒇(𝒙) = 𝒆−𝒙 − 𝒙
𝒙𝟎 = 𝟎 𝒙𝟏 = 𝟏
∈𝒂 < 𝟏%.
𝒊=𝟏
𝒇(𝒙𝟏 ) = −𝟎. 𝟔𝟑𝟐𝟏𝟐𝟏
𝒇(𝒙𝟎 ) = −𝟐
𝒊=𝟐
𝒇(𝒙𝟐 ) = 𝟎. 𝟎𝟕𝟒𝟑𝟏𝟒
Este método es muy bueno para obtener resultados de manera rápida y precisa
si se hace manualmente y, por lo que se pudo observar al momento de
programar, de igual manera es más fácil de manipular y realizar su código.
MÉTODOS NUMÉRICOS
GRUPO: 2SM1
2) Dominar la técnica del método y su confiabilidad, así como conocer las ventajas y
desventajas de este para seleccionar de forma oportuna diversos problemas
particulares aplicables al método.
4) Analizar los resultados obtenidos a través del programa para poder realizar una
comparación con los obtenidos manualmente.
5) Ser capaz de generar una matriz identidad a partir de una matriz ingresada por el
usuario.
MÉTODO DE GAUSS-JORDAN
Este método debe su nombre a Carl Friedrich Gauss y a Wilhelm Jordan. Se trata de una
serie de algoritmos del algebra lineal para determinar los resultados de un sistema de
ecuaciones lineales y así hallar matrices e inversas. El sistema de Gauss se utiliza para
resolver un sistema de ecuaciones y obtener las soluciones por medio de la reducción del
sistema dado a otro que sea equivalente en el cual cada una de las ecuaciones tendrá una
incógnita menos que la anterior. La matriz que resulta de este proceso lleva el nombre que
se conoce como forma escalonada.
Para resolver sistemas de ecuaciones lineales con el método Gauss Jordan, debemos en
primer lugar anotar los coeficientes de las variables del sistema de ecuaciones lineales
con la notación matricial, también se le llama matriz aumentada.
- d1 = x
- d2 = y
- d3 = z
Nota: El superíndice (n) significa que los elementos del vector del lado derecho se han
modificado n veces (en este caso 3).
SISTEMA A RESOLVER.
Dado el siguiente sistema de ecuaciones, resuelva por el método de Gauss – Jordan.
2 x1 6 x2 x3 38
3x1 x2 7 x3 34
8 x1 x2 2 x3 20
2 6 1 38 R1 ÷ 2 →R1
3 1 7 34
8 1 2 20
1 3 0.5 19
3 1 7 34 R1(3) + R2 →R2
8 1 2 20 R1(8) + R3→R3
1 3 0.5 19
0 10 5.5 91 R2 ÷ -10
0 23 6 172
1 0 2.15 8.3
0 1 0.55 9.1
0 0 18.65 37.3 R3 ÷ -18.65
1 0 0 4 x1 4
0 1 0 8 x2 8
x3 2
0 0 1 2
ALGORITMO
El Algoritmo de Gauss-Jordan consta de los siguientes pasos:
int main ()
{
//DECLARACIÓN DE LA MATRIZ
double MatA[100][100],aux[100],pivote=0.0;
//DECLARACIÓN DE LAS VARIABLES
int fil,i,j,k,n,m;
//SE IMPRIME EL MÉTODO DE RESOLUCIÓN
printf ("\n\tRESOLUCION DE SISTEMAS ECUACIONES POR EL METODO DE GAUSS - JORDAN\n");
//LEE EL NUMERO DE FILAS Y DE COLUMNAS DEL SISTEMA DE ECUACIONES
printf("\nIngrese el numero de ecuaciones del sistema: ");scanf("%d",&fil);
system("cls");
system("color 18");
if(j==i)
break;
if (MatA[j][i]!=0)
{
//ciclo para recorrer columnas
for (k=0;k<fil + 1;k++)
{
aux[k]=MatA[j][k];
//guarda elemento de la fila actual
MatA[j][k]=MatA[i][k];
//guarda elemento de la fila selecta para intercambio
MatA[i][k]=aux[k];
}
}
}
}
for (j=0;j<fil+1;j++)
{
printf("%0.6lf\t",MatA[i][j]);
}
}
printf("\n");
printf ("\n\t\t\tSISTEMA DE ECUACIONES EN PROCESO 1...\n");
for(i=0;i<fil;i++)
{
int j=0;
pivote=0.0;//reinicia el pivote
pivote = MatA[i][j];//obtencion de elemento pivote
printf("\n");
if(i==j)
{
for (j=0;j<=fil;j++)//recorre las columnas
{
//división de cada elemento de fila pivote entre pivote
MatA[i][j]= MatA[i][j]/pivote;
printf("%0.6lf\t",MatA[i][j]);
}
}
else
{
for(k=0;k<=fil;k++)//recorre las columnas
{
//reducción de la fila actual
MatA[i][k]= MatA[i][k] - MatA[i-i][j]*pivote;
printf("%0.6lf\t",MatA[i][k]);
j++;
}
}
}
printf("\n");
printf ("\n\t\t\tSISTEMA DE ECUACIONES EN PROCESO 2...\n");
for(i=0;i<fil;i++)//recorre filas
{
for (j=0;j<=fil;j++)//recorre columnas
{
if((i==j)&&(i!=0)&&(j!=0))
{
pivote=0.0;
pivote = MatA[i][j];
for(k=1;k<fil-1;k++)//recorre filas
{
for(i=0;i<=fil;i++)//recorre columnas
{
//división de cada elemento de fila pivote entre pivote
MatA[k][i]= MatA[k][i]/pivote;
}
}
}
}
}
for(i=0;i<fil;i++)
{
printf("\n");
for (j=0;j<=fil;j++)
{
printf("%0.6lf\t",MatA[i][j]);
}
}
printf("\n");
printf ("\n\t\t\tSOLUCION DEL SISTEMA DE ECUACIONES\n");
//INICIO DEL PROCESO ITERATIVO PARA MOSTRAR EL SISTEMA
for (i=0;i<fil;i++)
{
printf("\n");
for (j=0;j<=fil;j++)
{
printf("%0.6lf\t",MatA[i][j]);
}
}
printf ("\n\n\n\t\tLAS RAICES DEL SISTEMA DE ECUACIONES SON LAS SIGUIENTES: \n");
for (i=0;i<fil;i++)
{
printf ("\nX(%d)=%0.6lf",i+1,MatA[i][fil]);
}
return 0;
}
RESULTADOS
Se muestra en pantalla el nombre del método, y se pide al usuario que ingrese el número
de ecuaciones para así poder generar los espacios debidos para llenar el sistema. La
matriz es ingresada por el usuario.
Primeramente se muestra el sistema ingresado por el usuario, después presenta el
sistema reordenado en caso de que el sistema ingresado presentara ceros en la
diagonal principal , esto se hace con el propósito de que el programa sea más eficiente
para el usuario. En “sistema de ecuaciones en proceso 1¨ se muestra cuando el
programa hace ceros por debajo del elemento (1,1) con ayuda del pivoteo. En “sistema
de ecuaciones en proceso 2¨ se muestra cuando el programa normaliza la fila 2 y la
deja lista para iniciar el pivoteo y así generar ceros arriba y abajo del elemento (2,2). Por
último muestra al usuario la matriz identidad generando de esta forma los resultados del
sistema de ecuaciones (X1,X2,X3…).
CONCLUSIONES
Es claro que el método de Gauss – Jordan fue uno de los programas más laborioso
de este parcial, ya que elaborar un programa completo que incluyera diferentes
situaciones como por ejemplo el reordenar el sistema ingresado en caso de presentar
ceros, necesitó de un tiempo considerable. En este método es importante tener un
dominio del tema del pivoteo puesto que a lo largo de todo el trabajo ya sea manual o
a través de la programación se necesitó de ello. Como era de esperarse, una vez más
se ven reflejadas las ventajas de la programación dado que el tiempo invertido al
hacerlo a mano es mucho más que el que le toma resolverlo al programa, además de
que después de comparar los resultados se obtuvo una exactitud óptima.
Ramírez Ramos Jocelyn Marie.
El método de Gauss-Jordan es uno de los más efectivos cuando se requiere resolver
sistemas de ecuaciones simultaneas, aunque en la aplicación de los métodos
numéricos es más difícil poder convertir dicho método al lenguaje de las computadoras
puesto que existen múltiples casos para el acomodo y la creación de ceros dentro de
la matriz que inserte el usuario. Sin embargo, una vez que hemos realizado el código
podemos usarlo para resolver diferentes problemas.
Amaro Sánchez Ricardo Daniel
Refiriéndome a la programación del método, resultó bastante complicar de obtener su
código, se utilizaron más variables para el respaldo de datos y, aunque no sea tan
relevante, se hicieron más líneas de programación.
Este método resulta que es muy preciso si se realiza bien, aunque se hacen muchos
cálculos y de manera simultánea, lo que puede ser un problema para entender el
método.
Es un método muy bueno, pero como todos los presentados en este trabajo, tiene sus
ventajas y sus desventajas.
Gutiérrez Rosales Germán
Referencias
1. https://matematica.laguia2000.com/general/metodo-de-gauss-jordan, 01 de abril
2018
2. http://www.sp.sepi.esimez.ipn.mx/pluginfile.php/938/mod_resource/content/1/MÉT
ODO%20DE%20GAUSS-JORDAN.pdf, 01 de abril 2018
3. http://aniei.org.mx/paginas/uam/CursoMN/curso_mn_12.html, 01 de abril de 2018
INSTITUTO POLITÉCNICO NACIONAL
MÉTODOS NUMÉRICOS
GRUPO: 2SM1
Si tenemos en cuenta la peculiar forma de las matrices Q y R, resulta que todos los
sumandos para los que j > i en la parte izquierda son nulos, mientras que en la parte
X1 =
7.85
3.0
= 2.616667 ᵋa, 1 = 100%
X2 =
−19.3 − 0.1(2.616667)
7.0
= −2.794524 ᵋa, 2 = 100%
X3 =
71.4 − 0.3(2.616667) + 0.2(−2.794524)
10
= 7.005610 ᵋa, 3 = 100%
- j=1
7.85 + 0.1(−2.794524) + 0.2(7.005610)
X1 = = 2.990557
3.0
- j=2
7.85 + 0.1(−2.499625) + 0.2(7.000291)
X1 = = 3.000032
3.0
3.000032 − 2.990557
𝜀𝑎, 1 = | | 𝑥 100% = 0.31%
3.000032
−2.499988 − (−2.499625)
𝜀𝑎, 2 = | | 𝑥 100% = 0.014%
−2.499988
6.999999 − 7.000291
𝜀𝑎, 3 = | | 𝑥 100% = 0.004%
6.999999
ᵋ
- Como cada 𝜀𝑎 < s = 1% los resultados son:
j X1 - 𝜺𝒂 X2 - 𝜺𝒂 X3 - 𝜺𝒂
4. Hacemos el cálculo de 𝜀𝑎, 𝑛 de cada incógnita verificando que todos sean <𝜀𝑠
previamente establecido o requerido.
𝑋𝑛 (𝑎𝑐𝑡𝑢𝑎𝑙) − 𝑋𝑛 (𝑎𝑛𝑡𝑒𝑟𝑖𝑜𝑟)
𝜀𝑎, 𝑛 = | | 𝑥 100% = %
𝑋𝑛 (𝑎𝑐𝑡𝑢𝑎𝑙)
5. Si todas las 𝜀𝑎, 𝑛 < 𝜀𝑠 termina el método y los valores de las incógnitas
adquiridos hasta la última iteración son los resultados.
DIAGRAMA DE FLUJO
CÓDIGO
//Práctica 5: METODO DE GAUSS-SEIDEL
//Equipo 1 2SM1 ISISA
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main ()
{
int m, n, i, j, k=0, l=-1, h=1;
system("color F3");
n=n+1;
system("pause");
system("cls");
//Llenado de arreglo
printf("Ingresar:\n\n");
for (i=0;i<m;i++)
{
printf("Ecuacion %d\n",i+1);
for (j=0;j<n-1;j++)
{
printf("X%d:\t",j+1); scanf ("%lf",&e[i][j]);
}
printf("Constante:\t");
scanf("%lf",&e[i][n-1]);
printf("\n\n");
}
system("pause");
system("cls");
//imprimir arreglo
printf("Arreglo ingresado\n\n");
for (i=0;i<m;i++)
{
for (j=0;j<n;j++)
{
printf("\t%lf",e[i][j]);
}
printf("\n");
}
printf("\n");
//Evaluar arreglo
for(i=0;i<m;i++)
{
diagonal=e[i][i];
suma= 0.0;
for (j=0;j<n-1;j++)
{
if (i!=j)
{
suma=suma+e[i][j];
}
}
//printf ("%lf\n%lf\n",diagonal,suma);
if (suma>diagonal)
{
k=-1;
do
{
k++;
diagonal=e[i][k];
//printf ("%lf\n",diagonal);
suma= 0.0;
for (j=0;j<n-1;j++)
{
suma=suma+e[i][j];
//printf ("%lf\t",suma);
}
suma=suma-diagonal;
// printf ("%lf",suma);
// printf ("\n");
}while (diagonal<suma);
//printf ("Mayor que la suma %lf suma %lf\n",diagonal,suma);
for (j=0;j<n;j++)
{
a[k][j]=e[i][j];
}
}
else
{
for (j=0;j<n;j++)
{
a[i][j]=e[i][j];
}
}
}
//Arreglo acomodado
printf ("Arreglo acomodado\n\n");
for (i=0;i<m;i++)
{
for (j=0;j<n;j++)
{
printf ("\t%0.6lf",a[i][j]);
}
printf ("\n");
}
for (j=0;j<n-1;j++)
{
x[j]=0.0;
}
x[n]= 1;
suma= 0.0;
printf ("\n");
do
{
printf ("\n\tIteracion %d\n",h);
h++;
for (i=0;i<m;i++)
{
diagonal=a[i][i];
suma= 0.0;
for (j=0;j<n-1;j++)
{
if (i!=j)
{
//printf("%lf\n%lf\n",a[i][j],x[j]);
suma=a[i][j]*x[j]+suma;
//printf ("%lf\n",suma);
}
}
xa[i]=x[i];
x[i]=(a[i][n-1]-suma)/diagonal;
printf ("\nX%d=\t%.6lf",i+1,x[i]);
}
printf("\n\nErrores:\n");
for (j=0;j<n-1;j++)
{
E[j]=fabs((x[j]-xa[j])/x[j])*100;
printf("E%d%=\t%.6lf%c\n",j+1,E[j],37);
}
printf ("\n");
}while (E[0]>Es);
printf("Por lo tanto:\n");
for (i=0;i<m;i++)
{
printf("\tX%d = %.6lf", i+1, x[i]);
printf("\n");
}
return 0;
}
RESULTADOS
Al momento de hacer ejercicios con este método pude notar que es más claro
al resolver las operaciones a comparación con el de Gauss-Jordan (para
ejemplificar).