Metods lineales

FACULTAD DE INFORMÁTICA Y ELECTRÓNICA

ESCUELA DE INGENIERÍA ELECTRÓNICA CONTROL Y REDES
INDUSTRIALES

CATEDRA:

Métodos numéricos

TEMA:

Métodos de sistemas de ecuaciones lineales

Realizado por:

 jonnathan chamba 246138
 kevin mishqui 246125
 Henry saa 246080
 evelin gallegos

FECHA DE ELABORACION:

15 DE junio DEL 2011

FECHA DE PRESENTACION:

17 DE junio DEL 2011

MARCO TEORICO

CONOCIMIENTOS BASICOS

En general, en todos los procesos iterativos para resolver el sistema Ax=b se recurre a una cierta
matriz Q, llamada matriz descomposición, escogida de tal forma que el problema original adopte
la forma equivalente:

Qx = (Q-A)x+b (1)

La ecuación (1) sugiere un proceso iterativo que se concreta al escribir:

(2)

1. Método de Gauss con pivoteo parcial

. .. lik = aik /akk
aik = lik
A(i, k + 1 : n − 1) = A(i, k + 1 : n − 1)−lik∗A(k, k + 1 : n − 1)
bi = bi −lik∗bk . . .

En la matriz final A estará la información indispensable de L y de U

En el ejemplo anterior, la matriz final con información de L y U es :

En el método de Gauss clásico, únicamente se intercambian filas cuando el pivote, akk , es nulo o
casi nulo. Como el pivote (el elemento akk en la iteración k) va a ser divisor para el cálculo de lik, y
como el error de o a redondeo o de truncamiento se hace mayor cuando el divisor es cercano a

cero, entonces es muy conveniente buscar que el pivote sea grande en valor absoluto. Es decir, hay
que evitar los pivotes que sin ser nulos son cercanos a cero.

En el método de Gauss con pivoteo parcial se busca el elemento dominante, e o sea, el de mayor
valor absoluto en la columna k de la diagonal hacia abajo, es decir, entre los valores |akk |, |ak+1,k |,
|ak+2,k |, ..., |akn |, y se intercambian la fila k y la fila del valor dominante. Esto mejora
notablemente, en muchos casos, la precisión de la solución final obtenida.

Ejemplo .

Resolver por el método de Gauss con pivoteo parcial el siguiente sistema de ecuaciones.

4x1 + 3x2 − 2x3 + x4 = 4
3x1 +2x2 +x3 + 5x4 = -8
-2x1 + 3x2 +x3 + 2x4 = -7
-5x1 + x3 + x4 = -8

La matriz aumentada es

4 3 -2 1 4
3 2 1 5 -8
-2 3 1 2 -7
-5 0 1 1 -8

El valor dominante de A (1: 4,1 ) es -5 y está en la fila 4. Entonces se intercambian las filas 1 y 4

-5 0 1 1 -8
3 2 1 5 -8
-2 3 1 2 -7
-2 0 1 1 -8

Buscar ceros en las posiciones de a21, a31, a41 se hace da la manera habitual usando los valores
de lik =3/(-5)= -0.6, 0.4 y -0.8. Se obtiene

-5 0 1 1 -8
0 3 0,6 1,6 -3.8
0 0 -1.8 0 1.4
0 0 0 4.6667 -9.3333

Al resolver el sistema triangular superior, se encuentra la solución:
x=(1,0,-1,-2).

EJERCICIO

Considerar la matriz ampliada con las filas permutadas

y ahora construimos la matriz L1

Dando lugar al sistema triangular superior

Y con la aritmética empleada

2. METODO DE GAUSS JORDAN

El proceso de eliminación de Gauss - Jordan consiste en realizar transformaciones elementales en el
sistema inicial, destinadas a transformarlo en un sistema diagonal.

es un método por el cual pueden resolverse sistemas de ecuaciones lineales con n números
de variables, encontrar matrices y matrices inversas, en este caso desarrollaremos la primera
aplicación mencionada.
Para resolver sistemas de ecuaciones lineales aplicando este método, se debe en primer lugar
anotar los coeficientes de las variables del sistema de ecuaciones lineales en su notación matricial:

Entonces, anotando como matriz (también llamada matriz aumentada):

Una vez hecho esto, a continuación se procede a convertir dicha matriz en una matriz identidad, es
decir una matriz equivalente a la original, la cual es de la forma:

Esto se logra aplicando a las distintas filas y columnas de las matrices simples operaciones de
suma, resta, multiplicación y división; teniendo en cuenta que una operación se aplicara a todos los
elementos de la fila o de la columna, sea el caso.
Obsérvese que en dicha matriz identidad no aparecen los términos independientes, esto se debe a
que cuando nuestra matriz original alcance la forma de la matriz identidad, dichos términos
resultaran ser la solución del sistema y verificaran la igualdad para cada una de las variables,
correspondiéndose de la siguiente forma:
d1 = x
d2 = y
d3 = z
Ahora que están sentadas las bases, podemos explicar paso a paso la resolución de sistemas de
ecuaciones lineales por medio de este método.
Para ilustrarnos mejor lo analizaremos con un ejemplo concreto:
Sea el sistema de ecuaciones:

Procedemos al primer paso para encontrar su solución, anotarlo en su forma matricial:

Una vez hecho esto podemos empezar a operar con las distintas filas y columnas de la matriz
para transformarla en su matriz identidad, teniendo siempre en cuenta la forma de la misma:

Lo primero que debemos hacer es transformar el 2 de la 1ª fila de la matriz original en el 1 de la
1ª fila de la matriz identidad; para hacer esto debemos multiplicar toda la 1ª fila por el inverso
de 2, es decir ½.

Luego debemos obtener los dos ceros de la primera columna de la matriz identidad, para lograr
esto, buscamos el opuesto de los números que se ubicaron por debajo del 1 de la primera
columna, en este caso el opuesto de 3 que será -3 y el opuesto de 5 que será -5.
Una vez hecho esto, se procederá a multiplicar los opuestos de estos números por cada uno de los
elemento de la 1ª fila y estos se sumaran a los números de su respectiva columna. Por ej.: en el
caso de la 2º fila, se multiplicara a -3 (opuesto de 3) por cada uno de los elementos de la 1º fila y se
sumara su resultado con el numero que le corresponda en columna de la segunda fila. En el caso de
la 3ª fila se multiplicara a -5 (opuesto de 5) por cada uno de los elementos de la 1º fila y se sumara
su resultado con el número que le corresponda en columna de la tercera fila.

Nuestro siguiente paso es obtener el 1 de la 2ª fila de la matriz identidad, y procedemos de
igual forma que antes, es decir multiplicamos toda la fila por el inverso del numero que
deseamos transformar en 1, en este caso -13/2, cuyo inverso es -2/13

Ahora queremos obtener el 0 que se ubica en la 3ª fila, 2ª columna de la matriz identidad, para
hacer esto buscamos el opuesto del numero que se ubica en la 3ª fila, 2ª columna de la matriz
con la cual estamos operando, en este caso -17, cuyo opuesto será 17; lo que hacemos ahora es
multiplicar este número por todos los elementos de la 2ª fila y sumar esos resultados con el
numero que le corresponde en columna de la 3ª fila.

A esta altura podemos observar como la matriz con la cual estamos operando empieza a
parecerse a la matriz identidad.
Nuestro siguiente paso es obtener el 1 correspondiente a la 3ª fila, 3ª columna de la matriz
identidad, ahora bien, aplicamos el mismo procedimientocon el que estábamos trabajando, es
decir que vamos a multiplicar toda la 3ª fila por el inverso del numero que se encuentre en la
posición de la 3ª fila, 3ª columna, en este caso 96/13, cuyo inverso será 13/96.

Luego debemos obtener los dos ceros de la tercera columna de la matriz identidad, para lograr
esto, buscamos el opuesto de los números que se ubicaron por encima del 1 de la 3ª columna
de la matriz con la cual estamos operando, en este caso 11/13 y ½ cuyos opuestos serán - 11/13
y -½, respectivamente.
Una vez hecho esto, se procederá a multiplicar los opuestos de estos números por cada uno de los
elemento de la 3ª fila y estos se sumaran a los números de su respectiva columna. Por ej.: en el
caso de la 2º fila, se multiplicara a - 11/13 (opuesto de 11/13) por cada uno de los elementos de la
3º fila y se sumaran sus resultados con el número que le corresponda en columna de la segunda

fila. En el caso de la 1ª fila se multiplicara a -½ (opuesto de ½) por cada uno de los elementos de la
3º fila y se sumaran sus resultados con el número que le corresponda en columna de la primera
fila.

El último paso que debemos realizar es obtener el 0 de la 1ª columna, 2ª fila de la matriz
identidad, para hacer esto buscamos el opuesto del numero que se ubica en la 1ª columna, 2ª
fila de la matriz con la que estamos operando, en este caso es 3/2, cuyo opuesto será - 3/2, lo
que hacemos ahora es multiplicar este número por todos los elementos de la 2ª fila y sumar
esos resultados con el numero que le corresponde en columna de la 1ª fila.

Como podemos observar hemos llegado al modelo de la matriz identidad que buscábamos, y en
la cuarta columna hemos obtenido los valores de las variables, correspondiéndose de este
modo:
x= 1
y= -1
z= 2
Luego, el sistema de ecuaciones está resuelto y por último lo verificamos.
2x + 3y + z = 1 3x – 2y – 4z = -3 5x – y – z = 4
2*1+3*(-1)+2=1 3*1- 2*(-1)-4*2=-3 5*1-(-1)-2 =4
2 -3 +2 =1 3 +2 - 8= -3 5 +1 - 2 = 4
1 = 1 -3 = -3 4= 4

3. METODO DE GAUSS SEIDEL

La iteración de Gauss-Seidel se define al tomar Q como la parte triangular inferior de A incluyendo
los elementos de la diagonal:

Si, definimos la matriz R=A-Q

y la ecuación (2) se puede escribir en la forma:

Qx(k) = -Rx(k-1) + b

Un elemento cualquiera, i, del vector Qx(k) vendrá dado por la ecuación:

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 derecha son nulos todos los

sumandos para los que . Podemos escribir entonces:

=

=

de donde despejando xi(k), obtenemos:

Obsérvese que en el método de Gauss-Seidel los valores actualizados de xi sustituyen de inmediato
a los valores anteriores, mientras que en el método de Jacobi todas las componentes nuevas del
vector se calculan antes de llevar a cabo la sustitución. Por contra, en el método de Gauss-Seidel
los cálculos deben llevarse a cabo por orden, ya que el nuevo valor xi depende de los valores
actualizados de x1, x2, ..., xi-1.

4.METODO DE JACOBI
En la iteración de Jacobi, se escoge una matriz Q que es diagonal y cuyos elementos diagonales son
los mismos que los de la matriz A. La matriz Q toma la forma:

y la ecuación general (2) se puede escribir como

Qx(k) = (Q-A)x(k-1) + b (3)

Si denominamos R a la matriz A-Q:

la ecuación (3) se puede reescribir como:

Qx(k) = -Rx(k-1) + b

El producto de la matriz Q por el vector columna x(k) será un vector columna. De modo análogo, el
producto de la matriz R por el vector columna x(k-1) será también un vector columna. La expresión

anterior, que es una ecuación vectorial, se puede expresar por necuaciones escalares (una para
cada componente del vector). De este modo, podemos escribir, para un elemento i cualquiera y
teniendo en cuenta que se trata de un producto matriz-vector:

Si tenemos en cuenta que en la matriz Q todos los elementos fuera de la diagonal son cero, en el
primer miembro el único término no nulo del sumatorio es el que contiene el elemento diagonal qii,
que es precisamente aii. Más aún, los elementos de la diagonal de Rson cero, por lo que podemos
eliminar el término i=j en el sumatorio del segundo miembro. De acuerdo con lo dicho, la expresión
anterior se puede reescribir como:

de donde despejando xi(k) obtenemos:

que es la expresión que nos proporciona las nuevas componentes del vector x(k) en función de
vector anterior x(k-1) en la iteración de Jacobi.

El método de Jacobi se basa en escribir el sistema de ecuaciones en la forma:

(4)

Partimos de una aproximación inicial para las soluciones al sistema de ecuaciones y sustituimos
estos valores en la ecuación (4). De esta forma, se genera una nueva aproximación a la solución del
sistema, que en determinadas condiciones, es mejor que la aproximación inicial. Esta nueva
aproximación se puede sustituir de nuevo en la parte derecha de la ecuación (4) y así
sucesivamente hasta obtener la convergencia.

5. METODO DE DOOLITTLE

Obtenida la factorización, se usa para resolver un sistema de ecuaciones y calcular el
determinante. También se puede obtener la inversa si es necesario. En la factorización, se usa
pivotación parcial o bien no se utiliza ningún tipo de pivotación, según los casos. Pendiente de
incorporar la pivotación parcial equilibrada. En los cálculos, se utilizan los factores L y U, y si ha
habido pivotación, el vector de permutaciones de filas. Cuando se utiliza pivotación, es necesario
"precalcular" los elementos de la subcolumna, lo que introduce una etapa que es innecesaria en
Crout. La solución del ejercicio incluye la resolución paso a paso de los diferentes apartados hasta
obtener la solución final. En la factorización aparecen en diferente color los elementos de las filas
y columnas que se van obteniendo, como patrón visual del orden correcto de obtención de la
matriz factorizada. Los órdenes considerados para la matriz van de 3 a 5 y los ejercicios aparecen
de menor a mayor orden de la matriz.

La forma más sencilla de explicar el método LU es ilustrando el método de Gauss básico a través
de un ejemplo, como es el caso de la matriz dada a continuación y aplicando el procedimiento a un
sistema de cuatro ecuaciones con cuatro incógnitas:

En el primer paso, multiplicamos la primera ecuación por 12/6= 2 y la restamos a la segunda,
después multiplicamos la primera ecuación por 3/6 = 1/2 y la restamos a la tercera y finalmente
multiplicamos la primera ecuación por -6/6=-1 y la restamos a la cuarta. Los números 2, ½ y -1 son
los multiplicadores del primer paso del proceso de eliminación. El número 6 es el elemento pivote
de este primer paso y la primera fila, que no sufre modificación alguna, se denomina fila pivote. El
sistema en estos momentos tiene el siguiente aspecto:

En el siguiente paso del proceso, la segunda fila se emplea como fila pivote y -4 como elemento
pivote aplicamos del nuevo el proceso: multiplicamos la segunda fila por -12/-4=3 y la restamos de
la tercera y después multiplicamos la segunda fila por 2/(-4)=-1/2 y la restamos a la cuarta. Los
multiplicadores son en esta ocasión 3 y -1/2 y el sistema de ecuaciones se reduce a:

El último paso consiste en multiplicar la tercera ecuación por 4/2=2 y restarla a la cuarta. El
sistema resultante resulta ser:

El sistema resultante es triangular superior y equivalente al sistema original (las soluciones de
ambos sistemas coinciden). Sin embargo, este sistema es fácilmente resoluble aplicando el
algoritmo de sustitución regresiva. La solución del sistema de ecuaciones resulta ser:

Si colocamos los multiplicadores utilizados al transformar el sistema en una matriz triangular

inferior unitaria (L) ocupando cada uno de ellos la posición del cero que contribuyó a producir,
obtenemos la siguiente matriz:

Por otra parte, la matriz triangular superior (U) formada por los coeficientes resultantes tras
aplicar el algoritmo de Gauss (2), es:

Estas dos matrices nos dan la factorización LU de la matriz inicial de coeficientes, A, expresada por
la ecuación (1):

6. METODO DE CROUT

A: Matriz cuadrada de orden “n”.

A: Descompuesta en un producto de dos matrices A=B*C

a11  a1n
A   
an1  ann

Donde B es una matriz triangular inferior con 1 en la diagonal y C es una matriz triangular superior
, es decir:

1 0  0 0 c11 c11  c1,n 1 c1n
b21 1  0 0 0 c22  c2 , n 1 c2 n
B      C     
bn 1,1 bn 1, 2  1 0 0 0  cn 1,n 1 cn 1,n
bn1 bn 2  bn ,n 1 1 0 0  0 cnn

Resolver A * x = b equivale, trivialmente a resolver el sistema B * C * x = b.
Etapas de resolución:

a) Descomponer A en el producto de dos matrices del tipo anterior, A = B * C
b) Resolver el sistema B * y = b donde y = C * x
c) Resolver el sistema C * x = y
d) Veamos cada una de ellas en detalle:
e) a) Calcular dos matrices B y C del tipo citado tal que:

A B C

Calculo de la fila 1 de C y columna 1 de B

n
a1 j b1L cLj c1 j
L 1
n
a j1 b jL cL1 b j1 c11
L 1
Se obtiene pues:
c1 j a1 j j 1,  , n fila 1 de C

ai1
bi1 i 1,  , n columna 1 de B
c11
Calculo de la k_ésima fila de C y k_ésima columna de B

Suponiendo calculadas las anteriores
n k k 1
akj bkL cLj )
(1
bkL cLj2 )
(
bkL cLj ckj
L 1 L 1 L 1

1. Ya que bkl=0 “"L > k
2. Puesto que bkk=1

Luego:

k 1
ckj akj bkl cLj j k
L 1
n k 1
akj biL cLk biL cLk bik ckk
L 1 L 1

Finalmente:

k 1
1
bik aik biL cLk ; k i
ckk L 1

7. METODO DE CHOLEVSKI
En matemáticas, la factorización o descomposición de Cholesky toma su nombre del
matemático André-Louis Cholesky, quien encontró que una matriz simétrica definida
positiva puede ser descompuesta como el producto de una matriz triangular inferior y la
traspuesta de la matriz triangular inferior. La matriz triangular inferior es el triángulo de
Cholesky de la matriz original positiva definida. El resultado de Cholesky ha sido extendido
a matrices con entradas complejas. Es una manera de resolver sistemas de ecuaciones
matriciales y se deriva de la factorización LU con una pequeña variación.

Cualquier matriz cuadrada A con pivotes no nulos puede ser escrita como el producto de
una matriz triangular inferior L y una matriz triangular superior U; esto recibe el nombre
de factorización LU. Sin embargo, si A es simétrica y definida positiva, se pueden escoger
los factores tales que U es la transpuesta de L, y esto se llama la descomposición o
factorización de Cholesky. Tanto la descomposición LU como la descomposición de
Cholesky son usadas para resolver sistemas de ecuaciones lineales. Cuando es aplicable, la
descomposición de Cholesky es dos veces más eficiente que la descomposición LU.

DEFINICIÓN

En general, si A es Hermitiana y definida positiva, entonces A puede ser descompuesta como

donde L es una matriz triangular inferior con entradas diagonales estrictamente positivas y L*
representa la conjugada traspuesta de L. Esta es la descomposición de Cholesky.

La descomposición de Cholesky es única: dada una matriz Hermitiana positiva definida A, hay una
única matriz triangular inferior L con entradas diagonales estrictamente positivas tales que A = LL*.
El recíproco se tiene trivialmente: si A se puede escribir como LL* para alguna matriz invertible L,
triangular inferior o no, entonces A es Hermitiana y definida positiva.

El requerimento de que L tenga entradas diagonales estrictamente positivas puede extenderse
para el caso de la descomposición en el caso de ser semidefinida positiva. La proposición se lee
ahora: una matriz cuadrada A tiene una descomposición de Cholesky si y sólo si A es Hermitiana y
semidefinida positiva. Las factorizaciones de Cholesky para matrices semidefinidas positivas no
son únicas en general.

En el caso especial que A es una matriz positiva definida simétrica con entradas reales, L se puede
asumir también con entradas reales. Una Matriz D diagonal con entradas positivas en la diagonal
(valores propios de A), es factorizable como , donde es matriz cuya
diagonal consiste en la raíz cuadrada de cada elemento de D, que tomamos como positivos. Así:

La factorización puede ser calculada directamente a través de las siguientes fórmulas (en este caso
realizamos la factorizacón superior A = UT * U):

para los elementos de la diagonal principal, y:

para el resto de los elementos. Donde uij son los elementos de la
matriz U.

CODIGO FUENTE

METODO DE CHOLESKY

#include<stdio.h>
#include<math.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
int i,j,m,n,q,cont=0,w,s,ban=0,nt=0,h=2,fer;
float mayor,aux,suma;
float k[30][30],l[20][20],lt[20][20];
char continuar='S';
main()
{
while(toupper(continuar)=='S')
{
clrscr();
n=0;

for(i=1;i<=50;i++)
{
gotoxy(10+i,6);printf("");
}
gotoxy(30,4);printf("©© CHOLESKY ©©");

gotoxy(12,9);printf("* INGRESE LA FORMA MATRICIAL ");

gotoxy(12,11);printf("* CUANTAS VARIABLLES SON ?");
do
{
gotoxy(50,11);printf("* # = :");
gotoxy(60,11);scanf("%d",&m);
}
while(m<=2);
//ingreso de matriz
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m+1;j++)
{
gotoxy(n+10,i+14);scanf("%f",&k[i][j]);
n=n+6;
q=i;

}
}
//fin de ingreso de matriz

//forma matricial
gotoxy(10,16+q);printf("FORMA MATRICIAL");
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)
{
gotoxy(n+10,i+17+q);printf("%2.1f",k[i][j]);
n=n+6;
w=i;
}
}

////fin forma matricial
///verificar si es diagonal dominante
for(i=1;i<=m;i++)
{

for(j=i;j<=m;j++)

{
if(i==j)
{
if(k[i][j]<0)
{
mayor=k[i][j]*(-1);
}
mayor=k[i][j];
for(s=j+1;s<=m;++s)
{
if(k[j][s]<0)
{
aux=k[j][s]*(-1);
}
aux=k[j][s];
suma=suma+aux;
}
if(mayor>suma)
{
cont++;
}

}
}
}
if(cont==m)
{
gotoxy(30,i+9+q+w);printf("/ Si es estrictamente diagonal dominante");
}
else
{
gotoxy(30,i+9+q+w);printf("[X] No es estrictamente diagonal dominante");
}
///fin de diagonal dominante todo bien

nt=((m*m)-m)/2;

for(j=1;j<=m;++j)
{
for(i=h;i<=m;i++)
{
if(k[j][i]==k[i][j])
{
ban++;
}
}
h=h+1;
}

if(ban==nt)
{
gotoxy(30,15+q+w);printf("si tiene transpuesta");
fer=1;
}
else
{
fer=0;
gotoxy(30,15+q+w);printf("no tiene transpuesta");
}

if(fer==1)
{
l[1][1]=sqrt(k[1][1]);
for(i=2;i<=m;++i)
{
l[i][1]=k[1][i]/l[1][1];
}

l[2][2]=sqrt(k[2][2]-(l[2][1]*l[2][1]));
l[3][2]=(k[3][2]-(l[3][1]*l[2][1]))/l[2][2];

l[3][3]=sqrt(k[3][3]-(l[3][1]*l[3][1])-(l[3][2]*l[3][2]));
//desplegar l
//forma matricial
gotoxy(10,20+w+q);printf("* MATRIZ L ");
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)
{
gotoxy(n+10,i+20+w+q);printf("%2.1f",l[i][j]);
n=n+6;

}
}

////fin matriz l

//matriz l transpuesta
gotoxy(40,20+w+q);printf("* MATRIZ L TRANSPUESTA ");
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)
{

gotoxy(n+40,i+20+w+q);printf("%2.1f",l[j][i]);
n=n+6;
lt[j][i]=l[j][i];
}
}

//forma matricial
///transnpuesta
////fin matriz l transpuesta
}
else
{
gotoxy(10,30);printf("NO SE PUEDE RESOLVER POR ESTE METODO");
}

//gotoxy(10,70);printf("NUEVA EJECUCION(S/N)");
scanf("%s",&continuar);
}
}

METODO DE CROUT

#include<stdio.h>
#include<math.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
int i,j,m,n,q,ban=1,s,w,ze=2,z,d=1,g=2,t,y=1,p,ferm,e=0,r;
float mul,min,din,men ,multi;
float k[30][30],l[30][30],u[30][30];
char continuar='S';
main()
{
{
clrscr();
n=0;
for(i=1;i<=53;i++)
{
gotoxy(10+i,6);printf("±");
}
gotoxy(30,4);printf("}}} CROUT ");


do
{

gotoxy(50,11);printf("* # = :");
}
while(m<=2);
//ingreso de matriz
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m+1;j++)
{
n=n+6;
q=i;

}
}
////para la forma matricial
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)
{
n=n+6;
w=i;
}
}
q=i+13;
///L
for(i=1;i<=m;i++)
{

for(j=1;j<=m;j++)
{
if(i==j)
{
l[i][j]=1;
for(s=j+1;s<=m;++s)
l[j][s]=0;
}
}
}

//fin de L
//u

for(i=1;i<=m;i++)
{

for(j=i;j<=m;j++)
{
if(i==j)
{
if(ban==1)
{
for(s=1;s<=m;++s)
{
u[i][s]=k[i][s];
ban=0;
}
}
else
{
for(s=j-1;s>=1;--s)
{
u[i][s]=0;
}
}
}
}
}
//fin de u
//determinar u y l
for(s=2;s<=m;++s)
{
l[s][1]=k[s][1]/u[1][1];
}

u[2][2]=k[2][2]-(l[2][1]*u[1][2]);

for(i=3;i<=m;++i)
{
l[i][2]=(k[i][2]-(l[i][1]*u[1][2]))/u[2][2];
}

u[2][3]=k[2][3]-(l[2][1]*u[1][3]);
u[3][3]=k[3][3]-l[3][1]*u[1][3]-l[3][2]*u[2][3];
//fin de determinar l y u

gotoxy(10,8+w+q);printf("* MATRIZ U ");
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)

{
gotoxy(n+10,i+10+q+w);printf("%2.1f",l[i][j]);
n=n+6;
z=i;
}
}


for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)
{
gotoxy(n+50,i+10+q+w);printf("%2.1f",u[i][j]);
n=n+6;

}
}
///l*b=c u*x=b
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)
{
gotoxy(n+10,i+16+q+w+z);printf("%2.1f",u[i][j]);
n=n+6;

}
}

for(i=1;i<=m;++i)
{
// gotoxy(n+13,18+q+w+z);printf("X");
//gotoxy(n+17,i+16+q+w+z);printf("B[%d]",i);
//gotoxy(n+23,18+q+w+z);printf("=");
//gotoxy(n+30,i+16+q+w+z);printf("%2.1f",k[i][m+1]);
l[i][m+1]=k[i][m+1];

}

//hacer cero bajo la diagonal
for(t=1;t<=m-1;t++)
{
g=ze;
// d=y;
do
{

mul=l[d+1][t];
if(mul<0)
{
for(s=1;s<=m+1;++s)
{ l[d+1][s]=l[d+1][s]*(-1);}
}

mul=l[d+1][t];

for(p=t;p<=m+1;++p)
{

min=l[t][p]*(-mul);
l[g][p]=min+l[g][p];

}
++g;
y=d;
++d;

}
while((k[m][t]!=0)&&(d!=m));

ze=ze+1;
}
//fin de hace cero a la diagonal
///aki es
//hacer (+)

for(p=1;p<=m;++p)
{
for(j=p;j<=m;j++)
{
if(p==j)
{

if(l[j][p]<0)
{
for(r=1;r<=m+1;r++)
{
l[p][r]=l[p][r]*(-1);
}
}
}
}
}

//fin

///fin

for(i=1;i<=m;++i)
{

gotoxy(n+13,18+q+w+z);printf("X");
gotoxy(n+17,i+16+q+w+z);printf("X[%d]",i);
gotoxy(n+23,18+q+w+z);printf("=");
gotoxy(n+30,i+16+q+w+z);printf("%2.1f",l[i][m+1]);
}
//fin de desplegar b
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m+1;j++)
{
// gotoxy(n+50,i+q+w+z);printf("%1.1f",l[i][j]);
// n=n+6;
u[i][m+1]=l[i][m+1];
}
}

//hacer uno a la diagonal
for(i=1;i<=m;++i)
{

for(j=i;j<=m;++j)
{
if(j==i)
{
din=u[i][j];
for(s=i;s<=m+1;s++)
{
u[i][s]=u[i][s]/din;
}
}
}
}
//fin de hacer uno a la diagonal

//hacer positiva a la diagonal

//fin

//haciendo gauss jordan
for(i=1;i<=m-1;i++)

{

for(p=i;p>=1;p--)
{
e++;
for(j=p;j<=m+1;j++)
{
if(p==j)
{
multi=u[p][p+e];
if(multi<0)
{
for(r=1;r<=m+1;r++)
{
u[j][r]=u[j][r]*(-1);
}
}
multi=u[p][p+e];

}
men=u[p+e][j]*(-multi);
u[p][j]=u[p][j]+men;

}
}
e=0;
}

//fin de gauss jordan
//hacer (+)

for(p=1;p<=m;++p)
{
for(j=p;j<=m;j++)
{
if(p==j)
{

if(u[j][p]<0)
{
for(r=1;r<=m+1;r++)
{
u[p][r]=u[p][r]*(-1);
}
}
}
}

}
//fin
//desplegar x
for(i=1;i<=m;i++)
{
gotoxy(n+40,i+16+q+w+z);printf("sol: X[%d] = %2.1f",i,u[i][m+1]);
}
//fin
}
}

METODO DE DOOLITTLE

#include<stdio.h>
#include<math.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
int i,j,m,n,q,ban=1,s,w,ze=2,z,d=1,g=2,t,y=1,p,ferm,e=0,r;
float mul,min,din,men ,multi;
float k[30][30],l[30][30],u[30][30];
char continuar='S';
main()
{
{
clrscr();
n=0;
for(i=1;i<=50;i++)
{
gotoxy(10+i,6);printf("");
}
gotoxy(30,4);printf("©© DOOLITLE ©©");


do
{
gotoxy(50,11);printf("* # = :");
}
while(m<=2);
//ingreso de matriz
for(i=1;i<=m;i++)
{

n=0;
for(j=1;j<=m+1;j++)
{
n=n+6;
q=i;

}
}
////para la forma matricial
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)
{
n=n+6;
w=i;
}
}
q=i+13;
///L
for(i=1;i<=m;i++)
{

for(j=1;j<=m;j++)
{
if(i==j)
{
l[i][j]=1;
for(s=j+1;s<=m;++s)
l[j][s]=0;
}
}
}

//fin de L
//u
for(i=1;i<=m;i++)
{

for(j=i;j<=m;j++)
{
if(i==j)
{

if(ban==1)
{
for(s=1;s<=m;++s)
{
u[i][s]=k[i][s];
ban=0;
}
}
else
{
for(s=j-1;s>=1;--s)
{
u[i][s]=0;
}
}
}
}
}
//fin de u
//determinar u y l
for(s=2;s<=m;++s)
{
l[s][1]=k[s][1]/u[1][1];
}

u[2][2]=k[2][2]-(l[2][1]*u[1][2]);

for(i=3;i<=m;++i)
{
l[i][2]=(k[i][2]-(l[i][1]*u[1][2]))/u[2][2];
}

u[2][3]=k[2][3]-(l[2][1]*u[1][3]);
u[3][3]=k[3][3]-l[3][1]*u[1][3]-l[3][2]*u[2][3];
//fin de determinar l y u

for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)
{
gotoxy(n+10,i+10+q+w);printf("%2.1f",l[i][j]);
n=n+6;
z=i;
}
}

gotoxy(50,8+w+q);printf("* MATRIZ U ");

for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)
{
gotoxy(n+50,i+10+q+w);printf("%2.1f",u[i][j]);
n=n+6;

}
}
///l*b=c u*x=b
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m;j++)
{
gotoxy(n+10,i+16+q+w+z);printf("%2.1f",u[i][j]);
n=n+6;

}
}

for(i=1;i<=m;++i)
{
// gotoxy(n+13,18+q+w+z);printf("X");
//gotoxy(n+17,i+16+q+w+z);printf("B[%d]",i);
//gotoxy(n+23,18+q+w+z);printf("=");
//gotoxy(n+30,i+16+q+w+z);printf("%2.1f",k[i][m+1]);
l[i][m+1]=k[i][m+1];

}

//hacer cero bajo la diagonal
for(t=1;t<=m-1;t++)
{
g=ze;
// d=y;
do
{

mul=l[d+1][t];
if(mul<0)
{
for(s=1;s<=m+1;++s)
{ l[d+1][s]=l[d+1][s]*(-1);}
}

mul=l[d+1][t];

for(p=t;p<=m+1;++p)
{

min=l[t][p]*(-mul);
l[g][p]=min+l[g][p];

}
++g;
y=d;
++d;

}
while((k[m][t]!=0)&&(d!=m));

ze=ze+1;
}
//fin de hace cero a la diagonal
///aki es
//hacer (+)

for(p=1;p<=m;++p)
{
for(j=p;j<=m;j++)
{
if(p==j)
{

if(l[j][p]<0)
{
for(r=1;r<=m+1;r++)
{
l[p][r]=l[p][r]*(-1);
}
}
}
}
}
//fin

///fin

for(i=1;i<=m;++i)
{

gotoxy(n+13,18+q+w+z);printf("X");
gotoxy(n+17,i+16+q+w+z);printf("X[%d]",i);
gotoxy(n+23,18+q+w+z);printf("=");
gotoxy(n+30,i+16+q+w+z);printf("%2.1f",l[i][m+1]);
}

//fin de desplegar b
//aki kevin
for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m+1;j++)
{
// gotoxy(n+50,i+q+w+z);printf("%1.1f",l[i][j]);
// n=n+6;
u[i][m+1]=l[i][m+1];
}
}
for(i=1;i<=m;++i)
{

for(j=i;j<=m;++j)
{
if(j==i)
{
din=u[i][j];
for(s=i;s<=m+1;s++)
{
u[i][s]=u[i][s]/din;
}
}
}
}

//hacer positiva a la diagonal

//fin

for(i=1;i<=m-1;i++)
{

for(p=i;p>=1;p--)
{

e++;
for(j=p;j<=m+1;j++)
{
if(p==j)
{
multi=u[p][p+e];
if(multi<0)
{
for(r=1;r<=m+1;r++)
{
u[j][r]=u[j][r]*(-1);
}
}
multi=u[p][p+e];

}
men=u[p+e][j]*(-multi);
u[p][j]=u[p][j]+men;

}
}
e=0;
}

//hacer (+)

for(p=1;p<=m;++p)
{
for(j=p;j<=m;j++)
{
if(p==j)
{

if(u[j][p]<0)
{
for(r=1;r<=m+1;r++)
{
u[p][r]=u[p][r]*(-1);
}
}
}
}
}
//fin

// x borrar

for(i=1;i<=m;i++)
{
n=0;
for(j=1;j<=m+1;j++)
{
gotoxy(n+50,i+q+w+z);printf("%1.1f",u[i][j]);
n=n+6;

}
}
//

//desplegar x
for(i=1;i<=m;i++)
{
gotoxy(n+40,i+16+q+w+z);printf("sol: X[%d] = %2.1f",i,u[i][m+1]);
}
//fin
}
}

METODO DE GAUSS PIVOTEO PARCIAL

#include<stdio.h>
#include<math.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
int n,i,j,t,s,l,d=1,m,p,ban=0,z=2,g,w,x,q,f,y=1,u,e=0,r;
float aux=0,mul,den,min,o,din,multi,men;
float k[20][20];
char continuar='S';
main()
{
{
clrscr();
n=0;
for(i=1;i<=73;i++)
{
gotoxy(4+i,4);printf("_");
}

gotoxy(30,3);printf("©© PIBOTEO PARCIAL ©©");


gotoxy(12,8);printf("* M(columna) x N(fila)");

do
{
gotoxy(12,10);printf("* m =");
}

while(m<=2);
//ingreso de matriz
for(i=1;i<=m-1;i++)
{
n=0;
for(j=1;j<=m;j++)
{
n=n+6;
q=i;
}
}
q=i+13;

//cargando
for(int i=0;i<7;i++)
{
for(int j=1;j<8000;j++)

gotoxy(i*2+64,6);printf("±");
}
////cargando

for(t=1;t<=m-2;t++)
{

for(l=t;l<=m-1;l++)
{//inicio
if(k[l][t]<0)
{
for(n=1;n<=m;++n)
{k[l][n]=k[l][n]*(-1); }

}else{}
if(k[l][t]>=aux)
{
aux=k[l][t];
for(s=1;s<=m;s++)
{
o=k[l][s];
k[l][s]=k[t][s];
k[t][s]=o;
}
}else{}

}//fin
//visualizar matriz
f=q+2;
for(w=1;w<=m-1;w++)
{
n=0;
for(x=1;x<=m;x++)
{
gotoxy(n+10,w+f);printf("%2.1f",k[w][x]);
n=n+6;
q=w+f;
}
}

//fin de visualizacion de matriz
g=z;
d=y;
do
{

mul=k[d+1][t];
for(p=t;p<=m;++p)
{
if(ban==0)
{den=k[t][d];ban=1;}
min=k[t][p]/den*(-mul);
k[g][p]=min+k[g][p];

}
++g;
y=d;
++d;
}
while((k[m-1][t]!=0)&&(d!=m-1));
ban=0;
aux=0;

z=z+1;
}

//////

if(k[m-1][m-1]<0)
{
k[m-1][m-1]=k[m-1][m-1]*(-1);
k[m-1][m]=k[m-1][m]*(-1);
}
for(w=1;w<=m-1;w++)
{
n=0;
for(x=1;x<=m;x++)
{
n=n+6;
q=w+f;
}
}


for(i=1;i<=m-1;++i)
{
for(j=i;j<=m;++j)
{
if(j==i)
{
din=k[i][j];
for(s=i;s<=m;s++)
{
k[i][s]=k[i][s]/din;
}
}
}
}

//vizualizar matriz con diagonal en unos
for(w=1;w<=m-1;w++)
{
n=0;

for(x=1;x<=m;x++)
{
gotoxy(n+40,12+w);printf("%2.1f",k[w][x]);

n=n+6;

}
}

//fin
for(i=1;i<=m-2;i++)
{

for(p=i;p>=1;p--)
{
e++;
for(j=p;j<=m;j++)
{
if(p==j)
{
multi=k[p][p+e];
if(multi<0)
{
for(r=1;r<=m;r++)
{
k[j][r]=k[j][r]*(-1);
}
}
multi=k[p][p+e];

}
men=k[p+e][j]*(-multi);
k[p][j]=k[p][j]+men;

}
}
e=0;
}


///xxxxxborrar

for(w=1;w<=m-1;w++)
{
n=0;

for(x=1;x<=m;x++)
{

n=n+6;

}
}
////xxxxxborrar

for(i=1;i<=m-1;++i)
{
for(j=i;j<=m;++j)
{
if(i==j)
{
if(k[i][j]<0)
{
k[i][4]=k[i][4]*(-1);
}

}

}
}
//resultados
for(i=1;i<=m-1;++i)
{
gotoxy(39,24+i);printf(" * sol [x%d] : %2.2f",i,k[i][m]);
}

gotoxy(10,28+i);printf("DESEA UNA NUEV EJECUCION(S/N)");
}
}

METODO DE GAUSS JORDAN

#include<stdio.h>
#include<math.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
int n,i,j,t,s,l,d=1,m,p,ban=0,z=2,g,w,x,q,f,y=1,u,e=0,r;
float aux=0,mul,den,min,o,din,multi,men;
float k[20][20];
char continuar='S';
main()

{
{
clrscr();
n=0;
for(i=1;i<=73;i++)
{
gotoxy(4+i,4);printf("_");
}

gotoxy(30,3);printf("©© GAUSS JORDAN ©©");


gotoxy(12,8);printf("* M(columna) x N(fila)");

do
{
gotoxy(12,10);printf("* m =");
}

while(m<=2);
//ingreso de matriz
for(i=1;i<=m-1;i++)
{
n=0;
for(j=1;j<=m;j++)
{
n=n+6;
q=i;
}
}
q=i+13;
for(t=1;t<=m-2;t++)
{

for(l=t;l<=m-1;l++)
{//inicio
if(k[l][t]<0)
{
for(n=1;n<=m;++n)
{k[l][n]=k[l][n]*(-1); }
}else{}
if(k[l][t]>=aux)

{
aux=k[l][t];
for(s=1;s<=m;s++)
{
o=k[l][s];
k[l][s]=k[t][s];
k[t][s]=o;
}
}else{}

}//fin
//visualizar matriz
f=q+2;
for(w=1;w<=m-1;w++)
{
n=0;
for(x=1;x<=m;x++)
{
n=n+6;
q=w+f;
}
}

g=z;
d=y;
do
{

mul=k[d+1][t];
for(p=t;p<=m;++p)
{
if(ban==0)
{den=k[t][d];ban=1;}
min=k[t][p]/den*(-mul);
k[g][p]=min+k[g][p];

}
++g;
y=d;
++d;
}
while((k[m-1][t]!=0)&&(d!=m-1));
ban=0;
aux=0;

z=z+1;

}

//////

if(k[m-1][m-1]<0)
{
k[m-1][m-1]=k[m-1][m-1]*(-1);
k[m-1][m]=k[m-1][m]*(-1);
}
for(w=1;w<=m-1;w++)
{
n=0;
for(x=1;x<=m;x++)
{
n=n+6;
q=w+f;
}
}


for(i=1;i<=m-1;++i)
{
for(j=i;j<=m;++j)
{
if(j==i)
{
din=k[i][j];
for(s=i;s<=m;s++)
{
k[i][s]=k[i][s]/din;
}
}
}
}

for(i=1;i<=m-2;i++)
{

for(p=i;p>=1;p--)
{
e++;

for(j=p;j<=m;j++)
{
if(p==j)
{
multi=k[p][p+e];
if(multi<0)
{
for(r=1;r<=m;r++)
{
k[j][r]=k[j][r]*(-1);
}
}
multi=k[p][p+e];

}
men=k[p+e][j]*(-multi);
k[p][j]=k[p][j]+men;

}
}
e=0;
}


///xxxxxborrar

for(w=1;w<=m-1;w++)
{
n=0;
for(x=1;x<=m;x++)
{

n=n+6;

}
}
////xxxxxborrar

for(i=1;i<=m-1;++i)
{
for(j=i;j<=m;++j)
{
if(i==j)
{
if(k[i][j]<0)

{
k[i][4]=k[i][4]*(-1);
}

}

}
}
//resultados
for(i=1;i<=m-1;++i)
{

gotoxy(40,24+i);printf(" * sol [x%d] : %2.2f",i,k[i][m]);
}

gotoxy(10,28+i);printf("DESEA UNA NUEV EJECUCION(S/N)");
}
}

METODO DE GAUSS SEIDEL

#include<stdio.h>
#include<math.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
int n,i,m,j,q,ban=0,p,l,s,t,bany=1,indice,cont,fe,h=0;
float k[20][20];
float deno,r,aux,iteracion,error,bander,fi;
float v[20],f[30],fa[30];
char continuar='S';
main()
{
{
clrscr();
n=0;
for(i=1;i<=73;i++)
{
gotoxy(4+i,6);printf("Ü");
}
gotoxy(30,4);printf("©© GAUSS SEIDDEL ©©");


gotoxy(12,11);printf("* M [ # columnas ]");

do
{
gotoxy(50,11);printf("* m :");
}
while(m<=2);
gotoxy(12,13);printf("* Ingrese el Numero de iteraciones :");
gotoxy(60,13);scanf("%f",&error);
//ingreso de matriz
for(i=1;i<=m-1;i++)
{
n=0;
for(j=1;j<=m;j++)
{
n=n+6;
q=i;
}
}
q=i+13;
for(i=1;i<=m-1;++i)
{
gotoxy(50,14+i);printf("x[%d] :",i);
gotoxy(60,14+i);scanf("%f",&v[i]);
}
///convertir en (+) a x1,x2,x3
for(i=1;i<=m-1;i++)
{
//matriz(fila,columna)
for(j=i;j<=m;j++)
{

if(j==i)
{
if(k[i][j]<0)
{
for(p=1;p<=m;++p)
{k[j][p]=k[j][p]*(-1); }
}

}
}
}

///fin de convertir en (+) a x1,x2,x3

//haciendo uno a las variables
for(i=1;i<=m-1;++i)
{ deno=k[i][i];
for(j=1;j<=m;++j)
{
k[i][j]=k[i][j]/deno;
}
}

// visualizar (fila,columna)
for(i=1;i<=m-1;i++)
{
l=0;
for(j=1;j<=m;j++)
{
gotoxy(j+9+l,20+i);printf("%2.1f",k[i][j]);
l=l+6;
}
}

//fin de visualizar

for(i=1;i<=m-1;++i)
{
gotoxy(10+fe,28);printf("x[%d]",i);
fe=fe+12;
}
gotoxy(15+fe,28);printf("ERROR");

// resolucion
do
{
for(i=1;i<=m-1;++i)
{
for(j=i;j<=m;++j)
{
if(j==i)
{
for(s=j+1;s<=m-1;++s)
{
r=r-(k[j][s]*v[s]);
}
r=r+k[j][m];
for(t=j;t>1;--t)
{

r=r-(k[j][t-1]*v[t-1]);
}
v[j]=r;
if(bany==1)
{
f[j]=v[j]; bany=0;fa[j]=v[j];}

gotoxy(10+h,30+cont);printf("%2.2f",v[j]);
h=h+12;
}
}
r=0;
}

// fin de resolucion
//VER EL MAYOR DE LOS VECTORES

if(cont>0)
{
for(i=1;i<=m-1;++i)
{
if(v[i]<0)
{fi=v[i]*-1;}
else
{fi=v[i];}
if(fi>aux)
{
aux=fi;
indice=i;
}
}
//fin de sacar el mayor
bander=aux;

aux=0;

if(fa[indice]<0)
{fi=fa[indice]*(-1);}else{fi=fa[indice];}
iteracion=bander-fi;
gotoxy(15+fe,30+cont);printf("%2.2f",iteracion);
// gotoxy(20+fe,30+cont);printf("%2.2f",bander);

for(i=1;i<=m-1;++i)
{
fa[i]=v[i];
}

}
h=0;
cont=cont+1;
}
while(cont<=error);

gotoxy(8+fe,15+cont);printf("la ultima iteracion es el resultado");
}
}

METODO DE JACOBI

//Jacobi

#include <conio.h>
#include <stdio.h>
#include <iostream.h>
#include <math.h>

#define ITERA 50
#define Maxec 6 //numero maximo de ecuaciones

enum Boolean{False,True};

void lectura(double a[Maxec][Maxec+1],double x0[Maxec],double b[Maxec],int n)
{
int i,j;
clrscr();
cout<<"Por favor introduzca la matriz de coeficientes del sistema";
gotoxy(3+n*5,5);cout<<"= b";
gotoxy(3+(n/2)*5,5);cout<<"Ax";
for(i=0;i<n;i++)
{
for(j=0; j<n; j++)
{
gotoxy(3+j*5,7+i);
scanf("%lf",&a[i][j]);
}
gotoxy(3+j*5,7+i);cout<<"= ";
scanf("%lf",&b[i]);
}
for(i=1; i<=n; i++)
{

printf("x0(%d) = ",i);
scanf("%lf",&x0[i]);
}
}
//---------------------------------------------------------------------------
void enter(void)
{
int c;
do{
if (kbhit())
c=getch();
}while(c!=13);
}
//---------------------------------------------------------------------------
void main(void)
{
double x[Maxec]={0},x0[Maxec]={0},b[Maxec]={0};
double a[Maxec][Maxec+1]={0},s,eps;
int y,i,j,k,n;
Boolean valver=False;
char c,cad[25]={0};

clrscr();
gotoxy(30,1);cout<<"M‚todo de Jacobi";
gotoxy(1,5);cout<<"N£mero de ecuaciones ";
do{
cin>>n;
if (n>6)
cout<<"El sistema debe tener menos de 6 ecuaciones por cuestiones nde impresion en
pantallanGracias";
cout<<"nnN£mero de ecuaciones ";
}while(n>6);
lectura(a,x,b,n);
clrscr();
textcolor(14);
gotoxy(10,12);cprintf("Si la solucion no converge, presione ESC para terminar");
textcolor(10);
gotoxy(1,24);cprintf("Presione ENTER para continuar...");
textcolor(7);
enter();
k=0;
y=4;
eps=1e-5;
clrscr();
textcolor(10);
textcolor(14);
gotoxy(45,24);cprintf("Presione una tecla para continuar...");

textcolor(15);
gotoxy(4,2);printf("k x1 x2 x3 x4 x5 x6");
do{
for(i=0; i<n; i++)
{
s=0;
for(j=0; j<n; j++)
if((i-j)!=0)
s=s+a[i][j]*x0[j];
x[i]=(b[i]-s)/a[i][i];
}
for(i=0; i<n; i++)
{
sprintf(cad,"%.4f",x[i]);
x[i]=atof(cad);
sprintf(cad,"%.4f",x0[i]);
x0[i]=atof(cad);
}

for(i=0; i<n; i++)
{
if(fabs(x0[i]-x[i]) > eps)
valver=False;
else
valver=True;
x0[i]=x[i];
}
k++;
gotoxy(2,y);cout<<k;
for(i=0; i<n; i++)
{
gotoxy(8+i*11,y);printf("%5.4f",x[i]);
}
y++;
c=getch();
if(y>22)
{
y=4;
clrscr();
textcolor(10);
textcolor(14);
gotoxy(45,24);cprintf("Presione una tecla para continuar...");
textcolor(15);
gotoxy(4,2);printf("k x1 x2 x3 x4 x5 x6");
}
if (k>ITERA)
c=27;

}while(!(valver==True||c==27));
textcolor(15);
cout<<"n";
cprintf("DESPUES DE %d ITERACIONES",k);
cout<<"n";
cprintf("LA SOLUCION DEL SISTEMA ES : n"); printf("n");
for(i=0; i<n; i++)
cprintf(" x(%d) = %10.4f",i+1,x0[i]),cout<<"n";
getch();
}

BIBLIOGRAFIA

 http://es.scribd.com/doc/57065244/23/M%C2%B4etodo-de-Gauss-con-pivoteo-parcial
 http://www.uhu.es/320099001/Docencia/Tema8.pdf[1]
 http://pcmap.unizar.es/~pilar/pivote.pdf[1]
 http://www.monografias.com/trabajos72/resolucion-sistemas-metodo-gauss-
jordan/resolucion-sistemas-metodo-gauss-jordan.shtml[2]
 http://www.uv.es/diaz/mn/fmn.html [0]
 http://www.uv.es/diaz/mn/node36.html [3]
 http://www.uv.es/diaz/mn/node35.html [4]
 http://www.uv.es/diaz/mn/fmn.html
 http://pcm.dis.ulpgc.es/an/ejerc/sislin/SisLin.html

Metods lineales

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (19)

Similar a Metods lineales

Similar a Metods lineales (20)

Más de Ecuador

Más de Ecuador (8)

Último

Último (20)

Metods lineales