Actividad II

Crear una clase Matriz para manipular matrices que encapsule un array
bidimensional de números reales.

a)- Incluya en la clase métodos que nos permitan acceder y modificar

de forma segura los elementos de la matriz (esto es, las variables
de instancia deben ser privadas y los métodos han de comprobar la
validezde sus parámetros).
Una clase es creada con la palabra clave class. La declaración de una clase es
similar sintácticamente a una estructura (y tienen muchísimo que ver). Aquí
tenemos un ejemplo. La siguiente clase define un tipo llamado CRender, el cual
es usado para implementar operaciones de renderizado en este caso.

// Esto define la clase CRender

class CRender {
char buffer[256];
public:
void m_Renderizar();
};

Una vez que se ha definido una clase, se puede crear un objeto de ese tipo
usando el nombre de la clase. El nombre de la clase se convierte en un
especificador del nuevo tipo. Por ejemplo la siguiente declaración crea 2 objetos
llamados render1 y render2 del tipo CRender.

CRender render1, render2;

Para implementar una función que es un miembro de una clase, debe indicarle al
compilador a cual clase pertenece la función calificando el nombre de la función
con el nombre de la clase. Por ejemplo, esta es una manera de codificar la función
m_Renderizar().

void CRender::m_Renderizar()
{
strcpy(buffer, "C++ en wikibooks");
return;
}

El :: es llamado el operador de resolución de ámbito. Esencialmente le dice al

compilador que esta versión de m_Renderizar pertenece a la clase CRender.
Dicho de otra forma, :: declara que m_Renderizar se encuentra en el ámbito de
CRender. Varias clases diferentes pueden usar los mismos nombres de función. El
compilador sabe cuál función pertenece a cuál clase y esto es posible por el
operador de resolución de ámbito y el nombre de la clase.

Las funciones miembros de una clase sólo pueden ser llamadas relativas a un
objeto específico. Para llamar a una función miembro desde alguna parte del
programa que se encuentre fuera de la clase, se debe usar el nombre del objeto y
el operador de direcionamiento '.' ( punto ). Por ejemplo, lo siguiente llama a
m_Renderizar() en el objeto objeto1.

CRender objeto1, objeto2;

objeto1.m_Renderizar();
b. Escriba un método que nos permita sumar matrices.
Sumar matrices
La suma de dos matrices.
Para llevar a cabo el ejemplo hemos definido un método Java que nos permite sumar las
matrices. La signatura de dicho método será la siguiente:

1. public static int[][] sumarmatrices (int[][] m1,int[][] m2) throws

Exception {...}

Como podemos ver el método Java recibe dos matrices y devuelve una, que será el
resultado de la misma. Por otro lado puede generar una Exception. Este caso será cuando
las dimensiones de las matrices sean diferentes. Ya que cuando las dimensiones de las
matrices son diferentes, estas no se pueden sumar. Así la comprobación de las dimensiones
de las matrices las haremos apoyándonos en la propiedad length:

1. if ((m1.length == m2.length) && (m1[0].length==m2[0].length)){...}

En el caso de no coincidir los tamaños, es cuando elevamos la Exception.

1. if ((m1.length == m2.length) && (m1[0].length==m2[0].length)){

2. ...

3. } else

4. throw new Exception();}

En caso afirmativo procederemos a sumar los elementos de las matrices. Hay que recordar
que la suma de las matrices es la suma de todos sus elementos posición a posición. Por lo
tanto la suma es sencilla. Solo tenemos que recorrer todos los elementos y dejar el resultado
en la matriz destino. Así, lo primero es crear una matriz resultado de las mismas
dimensiones:

1. int[][] suma = new int[m1.length][m1[0].length];

Para recorrer los elementos nos apoyamos en un bucle for y, nuevamente, en la propiedad
length.
 1. for (int x=0; x < m1.length; x++) {

2. for (int y=0; y < m1[x].length; y++) {

3. suma[x][y]=m1[x][y]+m2[x][y];

4. }

5. }

Ahora solo nos quedará devolver la matriz con el resultado de la suma.

1. return suma;

Invocar el método es sencillo. Solo hay que tener en cuenta que puede soltar
una Exception y por lo tanto lo deberemos de invocar desde un método try-catch

1. int [][] matriz1 = {{2,4,4},{6,6,9}};

2. int [][] matriz2 = {{2,4,4},{6,6,9}};

3. int [][] matriz = new int[3][3];

4.

5. try {

6. matriz = sumarmatrices(matriz1,matriz2);

7. pintarmatriz(matriz);

8. } catch(Exception e){

9. System.out.println("Matrices de diferente dimensión");

10. }
c. Implemente un método que nos permita multiplicar matrices.
Multiplicar matrices
La multiplicación de matrices en Java es un poco más compleja. Pero solo por la mera
forma de lo que significa una multiplicación.
Y es que para multiplicar matrices lo que se realiza es una multiplicación de las filas por las
columnas.
Lo primero será definir nuestras dos matrices en Java:

1. int[][] m1 = {{1,0,2},{-1,3,1}};

2. int[][] m2 = {{3,1},{2,1},{1,0}};

Ahora, a fin de que el ejemplo quede más didácticamente entendible vamos a crear
variables con las filas y columnas de las matrices.

1. int fil_m1 = m1.length;

2. int col_m1 = m1[0].length;

3.
 4. int fil_m2 = m2.length;

5. int col_m2 = m2[0].length;

No es necesario que crees estas variables en tu programa y lo mejor es que utilices el valor
del atributo .length en cada uno de los casos.
Ahora pasamos con las comprobaciones. Hemos dicho que para poder multiplicar dos
matrices en Java tienen que coincidir el tamaño de las columnas de la primera matriz con el
tamaño de las filas de la segunda matriz.

1. if (col_m1 != fil_m2)

2. throw new RuntimeException("No se pueden multiplicar las

matrices");

En caso de que no coincidan lanzaremos una RuntimeException.

Ahora pasamos a crear la matriz resultado. Esta tendrá un tamaño de las filas de la primera
matriz con las columnas de la segunda matriz.

1. int[][] multiplicacion = new int[fil_m1][col_m2];

Ya tenemos todo preparado para poder empezar a multiplicar las matrices. Para realizar la
multiplicación vamos a apoyarnos en un bucle anidado que recorra la matriz multiplicación
y la rellene.

1. for (int x=0; x < multiplicacion.length; x++) {

2. for (int y=0; y < multiplicacion[x].length; y++) {

3. ...

4. }

5. }

Para rellenarla hay que considerar que las multiplicaciones son de filas por columnas.

0,0 -> 0,0*0,0 + 0,1*1,0 + 0,2*2,0

0,1 -> 0,0*0,1 + 0,1*1,1 + 0,2*2,1
1,0 -> 1,0*0,0 + 1,1*1,0 + 1,2*2,0
...

Es decir necesitamos un nuevo bucle que recorra la columna de la matriz1 y la fila de la

matriz2 multiplicando y sumando sus valores.
Así nuestro nuevo bucle quedará de la siguiente forma:

1. for (int x=0; x < multiplicacion.length; x++) {

2. for (int y=0; y < multiplicacion[x].length; y++) {

3. for (int z=0; z<col_m1; z++) {

4. multiplicacion [x][y] += m1[x][z]*m2[z][y];

5. }

6. }

7. }

De esta forma ya tenemos el código que nos permite multiplicar matrices en Java.

d. Cree un método con el que se obtenga la traspuesta de una matriz.

Transponer una matriz
A la hora de transponer una matriz lo que estamos haciendo es convertir todas sus filas en
columnas:
Lo primero para poder transponer una matriz en Java será definir la matriz mediante un
array bidimensional. En nuestro caso vamos a utilizar una matriz de números enteros:
 1. int[][] matriz = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};

Lo siguiente será crear la nueva matriz. Hay que tener en cuenta que el valor de la
dimensión de filas de la matriz transpuesta será el de las columnas de la matriz y el valor de
las columnas de la matriz transpuesta será el de las filas de la matriz original.

1. int[][] matrizT = new int[matriz[0].length][matriz.length];

Como se puede ver nos apoyaos en el atributo .length para saber el tamaño de las filas y
columnas de la matriz. Ahora nos apoyamos en bucles para poder recorrer la matriz e ir
haciendo la transposición. Como en otros casos utilizamos dos bucles anidados que
representen las coordenadas x,y

1. for (int x=0; x < matriz.length; x++) {

2. for (int y=0; y < matriz[x].length; y++) { ... }

3. }

4. }

Ahora pasamos a la asignación. A la hora de pasar las filas a columnas vemos que el orden
es el siguiente.

0,0 -> 0,0

0,1 -> 1,0
0,2 -> 2,0
1,0 -> 0,1
1,1 -> 1,1
1,2 -> 2,1
...

Es decir que estamos cambiando las coordenadas x,y de la matriz original en las
coordenadas y,x de la segunda. Por lo tanto la asignación será, si estamos recorriendo la
matriz original.

1. matrizT[y][x] = matriz[x][y];
Quedando el código del bucle:

1. for (int x=0; x < matriz.length; x++) {

2. for (int y=0; y < matriz[x].length; y++) {

3. matrizT[y][x] = matriz[x][y];

4. }

5. }

Como vemos es muy sencillo transponer una matriz en Java.