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

nnn

n

aa

aa

A

1

111

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

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:

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

Se obtiene pues:

Calculo de la k_ésima fila de C y k_ésima columna de B

Suponiendo calculadas las anteriores

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

Luego:

1

01

001

0001

1,21

2,11,1

21

nnnn

nn

bbb

bb

b

B

nn

nnnn

nn

nn

c

cc

ccc

cccc

C

000

00

0

,11,1

21,222

11,11111

CBA

1111

1

1

1

1

11

cbcba

ccba

jL

n

L

jLj

jLj

n

L

Lj

B de 1 columna

C de 1 fila

, ,1

, ,1

11

11

11

ni

nj

c

ab

ac

ii

jj

kj

k

L

LjkL

k

L

LjkL

n

L

LjkLkj ccbcbcba1

11

)2(

1

)1(

kkik

n

L

k

L

LkiLLkiLkj

k

L

Ljklkjkj

cbcbcba

kjcbac

1

1

1

1

1

Finalmente:

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.

ikcbac

bk

L

LkiLik

kk

ik ;1 1

1

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() { while(toupper(continuar)=='S') { clrscr(); n=0; for(i=1;i<=53;i++) { gotoxy(10+i,6);printf("±"); } gotoxy(30,4);printf("}}} CROUT "); 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 ////para la 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; } } q=i+13; ////fin forma matricial ///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; } } gotoxy(50,8+w+q);printf("* MATRIZ L "); 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 //gotoxy(10,70);printf("NUEVA EJECUCION(S/N)"); scanf("%s",&continuar); } } 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() { while(toupper(continuar)=='S') { clrscr(); n=0; for(i=1;i<=50;i++) { gotoxy(10+i,6);printf(""); } gotoxy(30,4);printf("©© DOOLITLE ©©"); 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 ////para la 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; } } q=i+13; ////fin forma matricial ///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 L "); 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]; } } //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

// 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 //gotoxy(10,70);printf("NUEVA EJECUCION(S/N)"); scanf("%s",&continuar); } } 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() { while(toupper(continuar)=='S') { clrscr(); n=0; for(i=1;i<=73;i++) { gotoxy(4+i,4);printf("_"); }

gotoxy(30,3);printf("©© PIBOTEO PARCIAL ©©"); gotoxy(12,6);printf("* INGRESE LA FORMA MATRICIAL "); gotoxy(12,8);printf("* M(columna) x N(fila)"); do { gotoxy(12,10);printf("* m ="); gotoxy(30,10);scanf("%d",&m); } while(m<=2); //ingreso de matriz for(i=1;i<=m-1;i++) { n=0; for(j=1;j<=m;j++) { gotoxy(n+10,i+12);scanf("%f",&k[i][j]); n=n+6; q=i; } } q=i+13; //fin de ingreso de matriz //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++) { gotoxy(n+10,w+f);printf("%2.1f",k[w][x]); n=n+6; q=w+f; } } //fin de visualizacion de matriz //hacer uno a la diagonal 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; } } } } //fin de hacer uno a la diagonal //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 //haciendo gauss jordan 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; } //fin de gauss jordan ///xxxxxborrar for(w=1;w<=m-1;w++) { n=0;

for(x=1;x<=m;x++) { gotoxy(n+40,19+w);printf("%2.1f",k[w][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)"); scanf("%s",&continuar); } } 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()

{ while(toupper(continuar)=='S') { clrscr(); n=0; for(i=1;i<=73;i++) { gotoxy(4+i,4);printf("_"); } gotoxy(30,3);printf("©© GAUSS JORDAN ©©"); gotoxy(12,6);printf("* INGRESE LA FORMA MATRICIAL "); gotoxy(12,8);printf("* M(columna) x N(fila)"); do { gotoxy(12,10);printf("* m ="); gotoxy(30,10);scanf("%d",&m); } while(m<=2); //ingreso de matriz for(i=1;i<=m-1;i++) { n=0; for(j=1;j<=m;j++) { gotoxy(n+10,i+12);scanf("%f",&k[i][j]); n=n+6; q=i; } } q=i+13; //fin de ingreso de matriz 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++) { gotoxy(n+10,w+f);printf("%2.1f",k[w][x]); n=n+6; q=w+f; } } //fin de visualizacion de matriz //hacer uno a la diagonal 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; } } } } //fin de hacer uno a la diagonal //haciendo gauss jordan 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; } //fin de gauss jordan ///xxxxxborrar 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; } } ////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)"); scanf("%s",&continuar); } } 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() { while(toupper(continuar)=='S') { clrscr(); n=0; for(i=1;i<=73;i++) { gotoxy(4+i,6);printf("Ü"); } gotoxy(30,4);printf("©© GAUSS SEIDDEL ©©"); gotoxy(12,9);printf("* INGRESE LA FORMA MATRICIAL "); gotoxy(12,11);printf("* M [ # columnas ]");

do { gotoxy(50,11);printf("* m :"); gotoxy(60,11);scanf("%d",&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++) { gotoxy(n+10,i+14);scanf("%f",&k[i][j]); n=n+6; q=i; } } q=i+13; //fin de ingreso de matriz 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"); //gotoxy(28,20);printf("NUEVA EJECUCION(S/N)"); scanf("%s",&continuar); } } 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 pantalla\nGracias"; cout<<"\n\nN£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); gotoxy(30,1);cout<<"M‚todo de Jacobi"; 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); gotoxy(30,1);cout<<"M‚todo de Jacobi"; 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