La Clase Matriz

Introducción.

Una matriz se define como un arreglo bidimensional de datos, que tiene n renglones y m columnas. Un elemento del arreglo puede ser identificado con a_ij

|a₁₁ a₁₂ a₁₃ ... a_1n |

|a₂₁ a₂₂ a₂₃ ... a_2n |

A = |a₃₁ a₃₂ a₃₃ ... a_3n |

| |

|a_m1 a_m2 a_m3 ... a_mm |

Algunas de las operaciones básicas que pueden realizarse con matrices son suma, resta y multiplicación. La división de matrices como tal no existe y en su lugar se calcula la inversa.

Suma de matrices.

Para que la sumar las matrices A y B, se requiere que las matrices tengan el mismo número de renglones y de columnas. Si queremos encontrar la suma C = A + B, cada elemento de la matriz C lo calculamos de la siguiente forma:

c_ij = a_ij + b_ij

para todos lo i,j en la matriz C

Resta de matrices.

En este caso, se deben cumplir las mismas propiedades que la resta de matrices y el calculo de los elemento de la matriz C se calculan como:

c_ij = a_ij - b_ij

para todos lo i,j en la matriz C

Multiplicación de matrices.

Para realizar el producto C = A*B tenemos que considerar que el producto existe si

1.- El número de columnas de A es igual al número de renglones de B.

C(n,l) = A(n,m)*B(m,l)

2.- Las dimensiones de la matriz resultante tendrá el mismo numero de renglones que la matriz A y el mismo número de columnas que la matriz B.

3.- El cálculo de los elementos de la matriz C se lleva a cabo haciendo :

c_ij = S _k=0..m-1 a_ik * b_k,j

para todos lo i,j en la matriz C

public class Matriz

{

int nren, ncol;

double datos[][];

/***********************************************************************

* crea una matriz nula

**********************************************************************/

public Matriz()

{

nren = 0;

ncol = 0;

}

/************************************************************************

* crea una matriz con n renglones y m columnas ***********************************************************************/

public Matriz(int n, int m)

{

inicializa(n, m);

}

/***********************************************************************

* Inicializa las variables para los constructores.

***********************************************************************/

private void inicializa(int r, int c)

{

// Si la matriz es nula reserva memoria.

if((nren == 0 && ncol ==0) || this == null)

{

nren = r;

ncol = c;

datos = new double[nren][ncol];

for(int i=0; i<r; i++)

for(int j=0; j<c; j++)

datos[i][j] = 0;

}

}

/************************************************************************

* Inicializa la matriz con un arreglo bidimensional

**********************************************************************/

public Matriz(double d[][]) {

// crea una matriz con n renglones y m columnas de puros ceros

nren = d.length;

ncol = d[0].length;

datos = new double[nren][ncol];

for (int i = 0; i < nren; i++)

for (int j = 0; j < ncol; j++)

datos[i][j] = d[i][j];

}

/**********************************************************************

* imprime el contenido en una matriz

*********************************************************************/

public void imprime()

{

int i, j;

if( (nren == 0) && (ncol == 0) )

{

System.out.println("No tiene informacion la matriz");

return;

}

for(i=0; i<this.nren; i++)

{

for(j=0; j<this.ncol; j++)

System.out.print(datos[i][j] + " ");

System.out.println(" ");

}

}

/*******************************************************

Algoritmo para suma de matrices

********************************************************/

public Matriz suma(Matriz a, Matriz b) {

if ( (a.nren != b.nren) || (a.ncol != b.ncol))

return null;

this.inicializa(a.nren, a.ncol);

for (int i = 0; i < a.nren; i++)

for (int j = 0; j < a.ncol; j++)

this.datos[i][j] = a.datos[i][j] + b.datos[i][j];

return this;

}

/*******************************************************

Algoritmo para resta de matrices

********************************************************/

public Matriz resta(Matriz a, Matriz b) {

if ( (a.nren != b.nren) || (a.ncol != b.ncol))

return null;

this.inicializa(a.nren, a.ncol);

for (int i = 0; i < a.nren; i++)

for (int j = 0; j < a.ncol; j++)

this.datos[i][j] = a.datos[i][j] - b.datos[i][j];

return this;

}

/*******************************************************

Algoritmo para multiplicacion de matrices

********************************************************/

public Matriz multiplica(Matriz a, Matriz b)

{

int i, j;

double suma;

if(a.ncol == b.nren)

{

inicializa(a.nren, b.ncol);

if(this.nren == a.nren && this.ncol == b.ncol)

{

for(i=0; i< this.nren; i++)

for(j=0; j< this.ncol; j++)

{

suma = 0;

for(int k=0; k<a.ncol; k++)

suma += a.datos[i][k]*b.datos[k][j];

this.datos[i][j] = suma;

}

return this;

}

else System.out.println("Matrices con diferente tamaño");

}

else System.out.println("Matrices con diferente tamaño");

return null;

}

/*******************************************************

Algoritmo para encontrar la transpuesta de un matriz

********************************************************/

public Matriz transpuesta(Matriz a)

{

inicializa(a.ncol,a.nren);

for(int i=0;i<nren;i++)

for(int j=0;j<ncol;j++)

this.datos[i][j]=a.datos[j][i];

return this;

}

}

Ejemplo de Uso

A continuación se presenta un ejemplo de cómo debe utilizarse la clase matriz.

public class ej073 {

public static void main(String[] args) {

double a[][] = {{1, 2, 3}, {4,5,6}};

double b[][] = {{1, 2}, {4,5}, {1, 2}};

Matriz C = new Matriz();

Matriz A = new Matriz(a);

Matriz B = new Matriz(b);

C.multiplica(A, B);

C.imprime();

double f[][] = {{4, 2, 1},{2, 6, 3},{1, 3, 10}};

A = new Matriz(f);

A.imprime();

double e[] = {10, 0, 0};

B = new Matriz(e);

B.imprime();

Matriz x = new Matriz();

x.Solucion_Sistema_Ecuaciones(A, B);

x.imprime();

}

}

Regresar.