// ======================================================================
// Objetivo: Permitir el uso y las operaciones de matrices
// Autor: J. Rafael R. Ochoa
// Fecha: Nov-2003, Dic-2003
// Derechos: SID - FIE - UMSNH
// ======================================================================
/* ===========================================================================================================
Se reciben las dimensiones de la matriz como argumento en el constructor
Observaciones:
1.- SOlo funciona para matrices de nUmeros complejos -por lo pronto-
C L A R O !!, los nUmeros escalares tambiEn funcionan sOlo hay que declararlos como complejos
<<< escalares = dobles, flotantes, enteros >>>
2.- E J E M P L O DE P R U E B A
-----------------------------------------------
Para la matriz:
5 -1 -2
-1 4 -3
-2 -3 8
Se harIa algo como esto:
Matriz MAT = new Matriz(3,3);
Complejo M[][] = new Complejo[3][3];
M[0][0] = new Complejo("5"); M[0][1] = new Complejo("-1"); M[0][2] = new Complejo("-2");
M[1][0] = new Complejo("-1"); M[1][1] = new Complejo("4"); M[1][2] = new Complejo("-3");
M[2][0] = new Complejo("-2"); M[2][1] = new Complejo("-3"); M[2][2] = new Complejo("8");
MAT.Invierte(M);
---------------------------------------------------------------------------------------------------
METODOS RECONOCIDOS:
===================================================================================================
// FIRMA DEL METODO METODO
===================================================================================================
Complejo[][] Suma(Complejo MAT1[][], Complejo MAT2[][]) ==> Suma (Nov_2003)
void Invierte(Complejo MAT[][]) ==> InversiOn (Dic_2003)
Complejo[][] Resta(Complejo MAT1[][], Complejo MAT2[][]) ==> Resta (Jun_2004)
Complejo[][] Producto(Complejo MAT1[][], Complejo MAT2[][]) ==> Producto (Jun_2004)
---------------------------------------------------------------------------------------------------
===========================================================================================================
*/
class Matriz
{
// DeclaraciOn de los elementos miembro
// CC es sOlo para hacer referencia a la clase complejo ya que no estA como estAtica
Complejo MAT[][], CC = new Complejo("1");
//_____________________________________________________
// C O N S T R U C T O R
//-----------------------------------------------------
Matriz(int Ren, int Col) { MAT = new Complejo[Ren][Col]; }
//_________________________________________________
// U T I L E R I A S
//-------------------------------------------------
// ClonaciOn
Complejo[][] Clonacion(Complejo ORIGEN[][])
{
Complejo Nuevo[][] = new Complejo[ORIGEN.length][ORIGEN.length];
for (int ren = 0; ren < ORIGEN.length; ren++)
for (int col = 0; col < ORIGEN.length; col++)
Nuevo[ren][col] = ORIGEN[ren][col];
return Nuevo;
}
// InserciOn de elementos
void InsertaElementos(int Ren, int Col, String CAD) { MAT[Ren][Col] = new Complejo(CAD); }
// Cambio de signo
void Negativo(Complejo MAT[][])
{
for(int Ren = 0; Ren < MAT.length; Ren++)
for(int Col = 0; Col < MAT.length; Col++)
MAT[Ren][Col] = CC.Negativo(MAT[Ren][Col]);
}
// ImpresiOn
void Imprime(Complejo MAT[][])
{
System.out.println("\n\nMATRIZ= ");
for (int r = 0; r < MAT.length; r++)
for (int c = 0; c < MAT[0].length; c++)
{
System.out.print("("+r+","+c+")= ");
MAT[r][c].Imprime();
}
}
//_______________________________________
// M E T O D O S
//---------------------------------------
// Suma
//____________________________________________________
Complejo[][] Resta(Complejo MAT1[][], Complejo MAT2[][])
{
Complejo RESP[][] = new Complejo[MAT1.length][MAT1[0].length];
for (int ren = 0; ren < MAT1.length; ren++)
for (int col = 0; col < MAT1[0].length; col++)
RESP[ren][col] = MAT1[0][0].Resta(MAT1[ren][col], MAT2[ren][col]);
return RESP;
}
// Suma
//____________________________________________________
Complejo[][] Suma(Complejo MAT1[][], Complejo MAT2[][])
{
Complejo RESP[][] = new Complejo[MAT1.length][MAT1[0].length];
for (int ren = 0; ren < MAT1.length; ren++)
for (int col = 0; col < MAT1[0].length; col++)
RESP[ren][col] = MAT1[0][0].Suma(MAT1[ren][col], MAT2[ren][col]);
return RESP;
}
// InversiOn por el mEtodo de Shipley
//____________________________________________________
void Invierte(Complejo MAT[][])
{
int Orden = MAT.length; // Orden de la matriz
Complejo ORIGINAL[][];
for (int Pivote = 0; Pivote < Orden; Pivote++)
{
// Respaldo de la matriz
ORIGINAL = Clonacion(MAT);
// CAlculo del pivote
MAT[Pivote][Pivote] = CC.Negativo(CC.Reciproco(ORIGINAL[Pivote][Pivote]));
// CAlculo del renglOn y de la columna del pivote
for(int RC = 0; RC < Orden; RC++)
{
if (Pivote != RC)
{
MAT[RC][Pivote] = CC.Negativo(CC.Division(ORIGINAL[RC][Pivote], ORIGINAL[Pivote][Pivote]));
MAT[Pivote][RC] = CC.Negativo(CC.Division(ORIGINAL[Pivote][RC], ORIGINAL[Pivote][Pivote]));
}
}
// CAlculo de los elementos fuera de la columna y renglOn del pivote
for(int Ren = 0; Ren < Orden; Ren++) for(int Col = 0; Col < Orden; Col++)
{ if (Pivote != Ren && Pivote != Col)
MAT[Ren][Col] = CC.Resta(ORIGINAL[Ren][Col], CC.Division(CC.Producto(ORIGINAL[Ren][Pivote], ORIGINAL[Pivote][Col]),ORIGINAL[Pivote][Pivote]));
}
}
// Cambio de signo a toda la matriz
Negativo(MAT);
/* VerificaciOn */ Imprime(MAT);
}
// Producto
//____________________________________________________
Complejo[][] Producto(Complejo MAT1[][], Complejo MAT2[][])
{
Complejo RESP[][] = new Complejo[MAT1.length][MAT2[0].length];
Complejo ACUMULADO;
for (int ren_1 = 0; ren_1 < MAT1.length; ren_1++) // renglones de la matriz 1
{
for (int col_1 = 0; col_1 < MAT2[0].length; col_1++) // columnas de la matriz 2
{
ACUMULADO = new Complejo();
for (int ren_2 = 0; ren_2 < MAT2.length; ren_2++) // renglones de la matriz 2
{
System.out.println("ren1= " + ren_1 + " col1= " + ren_2);
System.out.println("ren2= " + ren_2 + " col2= " + col_1);
ACUMULADO = CC.Suma(ACUMULADO, CC.Producto(MAT1[ren_1][ren_2], MAT2[ren_2][col_1]));
}
RESP[ren_1][col_1] = ACUMULADO;
}
}
return RESP;
}
}