Re: Gauss-Jordan

["Humberto Goulart Rigotti" <hrigotti@uol.com.br>]

/* Eis o programa */
/* Qualquer sugestao sera bem-vinda */
/* P.S.: Não está otimizado */

#define NULO (-1)
#define TRUE 1
#define FALSE 0
#define M 10
#define N 10

main()
{
float E[M][N], D[M][N], F[M][N], G[M][N], C[M][N], ah, ai;
int p, q, h, k, i, j, limiteN, limiteM, P[M], MM[M], Q[N];

printf("Multiplicação de Matrizes.\n");
printf("M x N = "); scanf("%d %d", &limiteM, &limiteN);
if(limiteM>M) limiteM=M; if(limiteN>N) limiteN=N;

/* Preencher F e G com identidade */
identidade(F,limiteM); identidade(G,limiteM);

inclui_dados(D,"D",limiteM, limiteN); copia_matriz(D,E,limiteM, limiteN);

/* Inicializar P[], MM[] e Q[] */
for (i=0;i<limiteM;i++) {P[i]=(NULO); MM[i]=i;};
for (i=0;i<limiteN;i++) Q[i]=(NULO);

while (escalonada(E, P, limiteM, limiteN)==FALSE) {
    // mostra_matriz(F,"F",limiteM,limiteM);
    // mostra_matriz(G,"G",limiteM,limiteM);
    mostra_matriz(E,"E",limiteM,limiteN);

    h = escolhe_h(E, limiteM, P);
    k = escolhe_k(E, h, limiteN);    printf("h= %d, k= %d ",h+1,k+1);

    /*  P I V O T A C A O  */
    for(i=0;i<limiteM;i++) {F[i][h] = D[i][k];};

    ah = 1/E[h][k];      printf(", ah= %f ",ah); printf(", ai= { ");
    for (i=0;i<limiteM;i++) {
        ai = E[i][k]/E[h][k];     if (i != h) printf("%f ",ai);
        for(j=0;j<limiteN;j++) {
            if(i==h) { G[i][j] = ah * G[i][j]; E[i][j] = ah * E[i][j]; }
            else {
                  G[i][j] = G[i][j] - ai*G[h][j];
                  E[i][j] = E[i][j] - ai*E[h][j];
                 }
        }
    }
        printf(" }\n");
    inclui_P(P, h, limiteM);
    retira_M(MM, h, limiteM);
}

printf("\n---------------------------\n");
mostra_matriz(F,"F",limiteM,limiteM); mostra_matriz(G,"G",limiteM,limiteM);
multiplica(F,G,C,limiteM,limiteM); mostra_matriz(C,"FG",limiteM,limiteM);

multiplica(G,D,C,limiteM,limiteN); mostra_matriz(C,"GD",limiteM,limiteN);
mostra_matriz(E,"E",limiteM,limiteN);
}

multiplica(float MTA[M][M], float MTB[M][N], float MTC[M][N], int nc, int
nl)
{

int i,j,k;
for (i=0;i<nl;i++)
    for (j=0;j<nc;j++) {
        MTC[i][j] = 0;
        for (k=0;k<nc;k++)
            MTC[i][j] = MTC[i][j] + (MTA[i][k] * MTB[k][j]);
    }
}

identidade (float MT[M][M], int lim)    /* preenche MT com matriz identidade
*/
{
int i, j;

if (lim>M) lim = M;

for (i=0;i<lim;i++) {
    for (j=0;j<lim;j++) {
        if (i==j) MT[i][j] = 1;
        else MT[i][j] = 0;
        }
    }
}

mostra_matriz (float MT[M][N], char name[], int lim, int lim2)
{
  int i, j;

  if (lim>M) lim = M; if (lim2>N) lim2 = N;
  for (i=0;i<lim;i++)
  {
      printf("%s[%2d, ] = ", name, i+1);
      for (j=0;j<lim2;j++) printf("%4.1f ", MT[i][j]);
      printf("\n");
  }
  printf("\n");
}

inclui_dados(float MT[M][N], char nome[], int limiteM, int limiteN)
{
int i, j;
for (i=0;i<limiteM;i++)
{
    for (j=0;j<limiteN;j++)
    {
        printf("%s[%d,%d] = ",nome,i,j);
        scanf("%f", &MT[i][j]);
    }
    printf("\n");
}
}

copia_matriz(float MTA[M][N], float MTB[M][N], int limiteM, int limiteN)
{
int i, j;
for (i=0;i<limiteM;i++)
    for (j=0;j<limiteN;j++) {MTB[i][j] = MTA[i][j];};
}

int linha_nula(float vE[M][N], int linha, int limCols)
{
    int dj, flag = TRUE;
    for(dj=0;dj<limCols;dj++)
        if (vE[linha, dj] != 0) { flag = FALSE; break; }
    return flag;
}

int linha_OK(int linha, int vP[M], int limM)
{
    int dj, flag = TRUE;
    for(dj=0;dj<limM;dj++)
        if (vP[dj]==linha) { flag = FALSE; break; }
    return flag;
}

int escolhe_h(float E[M][N], int limM, int P[M])
{
    int h, i, j;

    for (i=0;i<limM;i++)
        if (linha_OK(i, P, limM)==TRUE)
            if (linha_nula(E, i, limM)==FALSE) { h = i; break; };
    return h;
}

inclui_P(int P[M], int h, int limM)
{
int dj;
    for (dj=0;dj<limM;dj++)
        if(P[dj]==(NULO)) { P[dj]=h; break;}
}

retira_M(int MM[M], int h, int limM)
{
int dj;
    for (dj=0;dj<limM;dj++)
        if(MM[dj]==h) { MM[dj]=(NULO); break; }
}

int escalonada(float E[M][N], int P[M], int limM, int limN)
{
    int di, dj, escal = TRUE;
    for (di=0;di<limM;di++)
        if (linha_OK(di, P, limM)==TRUE) /* di nao pertence a P */
            for(dj=0;dj<limN;dj++)
                if (E[di][dj] != 0) { escal = FALSE; break; }
    return escal;
}

int escolhe_k(float E[M][N], int h, int limN)
{
    int dk, k;
    for (dk=0;dk<limN;dk++)
        if (E[h][dk] != 0) { k = dk; break; }
    return k;
}