jueves, 23 de febrero de 2012

Triangularizar matriz

Programa que se utiliza como función en otros, como es el caso de resolución de sistemas mediante eliminación gaussiana, ortogonalización... Pienso que puede ser útil por si alguien lo quisiera utilizar como función en otro programa principal.

program triangulariza(input,output);
Const
  tanMax=20;
  precision=0.000001;

Type
  tpVector=array[1..tanMax] of real;
  tpMatriz=array[1..tanMax] of tpVector;
  tpDimension=1..tanMax;
  tpContador=1..MAXINT;

Var
  matriz:tpMatriz;
  min,pasoF,pasoC,filas,columnas:tpDimension;
  cont:tpContador;


Procedure LeerDatos(VAR f,c:tpDimension; VAR m:tpMatriz);
  Var
    i,j:tpContador;

  begin
    writeln('Introduzca el numero de filas: '); readln(f); writeln;
    writeln('Introduzca el numero de columnas: '); readln(c); writeln;
    for i:=1 to f do begin
      writeln('Termino de la fila ',i,': ');
      for j:=1 to c do begin
        write('Termino (',i,',',j,'): ');readln(m[i,j])
      end;
      writeln
    end;
    writeln
  end;


Procedure SeleccionarFila(f,c,pF,pC:tpDimension; VAR m:tpMatriz);
  Var
    i,j:tpContador;
    aux:real;

  Begin
    i:=pF;
    while (m[i,pC]<precision) and (i<f) and (m[i,pC]>-precision) do
      i:=i+1;
    If i<>f then
      begin
        for j:=pC to c do begin
          aux:=m[pF,j];
          m[pF,j]:=m[i,j];
          m[i,j]:=aux
        end
      end
  end;


Procedure restarFilas(f,c:tpDimension; VAR pF:tpDimension; VAR pC:tpDimension; VAR m:tpMatriz);
  var
    i,j:tpContador;
    aux:real;

  begin
    if m[pF,pC]<>0 then begin
      for i:=(pF+1) to f do begin
        aux:=m[i,Pc];
        for j:=pC to c do
          m[i,j]:=m[i,j]-aux*(m[pF,j]/m[pF,pC]);
      end;
      pF:=pF+1
    end;
    pC:=pC+1
  end;


procedure MinDim(f,c:tpDimension; VAR mini:tpDimension);
  begin
    if c<f then mini:=c else mini:=f
  end;


procedure EscribirMatriz(m:tpMatriz);
  var
    i,j:tpContador;

  begin
    for i:=1 to filas do begin
      for j:=1 to columnas do
        write(m[i,j]:7:2);
      writeln
    end
  end;

begin
  LeerDatos(filas,columnas,matriz);
  MinDim(filas,columnas,min);
  EscribirMatriz(matriz);writeln; writeln;
  pasoF:=1; pasoC:=1;
  for cont:=1 to min do
    begin
      SeleccionarFila(filas,columnas,pasoF,pasoC,matriz);
      restarFilas(filas,columnas,pasoF,pasoC,matriz)
    end;
  EscribirMatriz(matriz);
  readln
end.



Un saludo y que les sirva.









1 comentario:

  1. He creado una función de triangularización en C:

    #include

    main()
    {
    int i, j, k, l, vacias=0, inicial, fil, col;
    float MAT[22][22], PASO1 [22][22], RESULTADO[22][22], PASO2[22];

    printf("\nIntroduzca las dimensiones de la nueva matriz (filas y columnas).\nSepare ambos valores por un espacio.\n");
    scanf("%d %d", &fil, &col);

    for(i=0; i<fil; i++)
    {
    printf("\nIntroduzca los elementos de la fila %d, separados por un espacio: ", i+1);

    for(j=0; j<col; j++)
    {
    scanf("%f", &MAT[i][j]);
    }
    }



    for(i=0; i<fil; i++)
    for(j=0; j<col; j++)
    RESULTADO[i][j] = MAT[i][j];


    for(i=0; i<col; i++) //Rastrea cada columna
    {
    inicial = i-vacias;

    for(j=0; j<fil; j++)
    for(k=0; k<col; k++)
    PASO1[j][k] = RESULTADO[j][k];

    for(j=(i-vacias); j<fil; j++) //Busca "No 0"
    if (RESULTADO[j][i]!=0) break;

    if (j != fil) //Si lo encuentra, lo pone el primero y elimina lo que haya debajo
    {

    for(k=i; k<col; k++)
    {
    PASO2[k] = PASO1[j][k];
    RESULTADO[j][k] = PASO1[inicial][k];
    RESULTADO[inicial][k] = PASO2[k];
    }

    for(j=0; j<fil; j++)
    for(k=0; k<col; k++)
    PASO1[j][k] = RESULTADO[j][k];

    for (j=(inicial+1); j<fil; j++)
    {
    for(k=i; k<col; k++)
    {
    printf("ANTES: %f\n", RESULTADO[j][k]);

    printf("\n%f\n", (PASO1[j][k]*PASO1[inicial][i] - PASO1[inicial][k]*PASO1[j][i]));
    RESULTADO[j][k] = PASO1[j][k]*PASO1[inicial][i] - PASO1[inicial][k]*PASO1[j][i];

    printf("DESPUES: %f\n", RESULTADO[j][k]);
    }

    for(l=0; l<fil; l++)
    for(k=0; k<col; k++)
    PASO1[l][k] = RESULTADO[l][k];
    }
    for(j=0; j<fil; j++)
    {
    for(k=0; k<col; k++)
    printf("%g ", RESULTADO [j][k]);
    printf("\n");
    }
    }

    else vacias++;//Si no lo encuentra, hay una columna vacia
    }

    for(i=0; i<fil; i++)
    {
    for(j=0; j<col; j++)
    printf("%g ", RESULTADO[i][j]);
    printf("\n");
    }

    return(0);
    }

    El problema que le veo es que parece incorrecta, porque al multiplicar los elementos de la diagonal no da como resultado el determinante.

    ResponderEliminar