Matriz 3: Matriz Cuadrada, nula, diagonal, escalar

En esta ocasión tendremos las siguientes operaciones de matrices:

 

  • Determinar si una matriz es cuadrada.
  • Determinar si una matriz es nula.
  • Determinar si una matriz es diagonal.
  • Determinar si una matriz es escalar.

 

La forma de trabajar será de la siguiente manera:

 

  • Crear un menú para elegir la operación deseada.
  • En cada operación se pedirá el tamaño de la matriz al usuario.
  • En caso de que se requiera pedir datos para llenar las celdas de las matrices se deberán llenar manualmente (digitados por el usuario).
  • Evaluar la matriz y obtener el resultado.

 

Creando el menú

 

Crearemos un menú básico con JOptionPane como lo hicimos en Ciclo Do - While 1: Menú.

int op=0;
String menu="";
do{
    menu="";
    menu+="******** Menú ********\n";
    menu+="1.- Matriz cuadrada \n";
    menu+="2.- Matriz Nula \n";
    menu+="3.- Matriz Diagonal \n";
    menu+="4.- Matriz Escalar \n";        
    menu+="5.- Salir \n";
    menu+="Elija una opción";
    op=Integer.parseInt(JOptionPane.showInputDialog(menu));
    switch(op){
        case 1:
            break;
        case 2:
            break;  
        case 3:
            break;  
        case 4:
            break;   
    }
}while(op!=5);

Matriz cuadrada

 

Una matriz cuadrada es aquella que tiene el mismo número de filas que de columnas, ejemplo:

 

Recordar que para saber el número de fila o columnas de una matriz se puede hacer con la variable pública length de cualquier arreglo.

case 1:
     int filas=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas de la matriz"));
     int columnas=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas de la matriz"));
     int matriz[][]=new int[filas][columnas];
                        
     if(matriz.length==matriz[0].length)
        JOptionPane.showMessageDialog(null, "Si es cuadrada");
     else
        JOptionPane.showMessageDialog(null, "No es cuadrada");
                        
     break;

Matriz Nula

 

Una matriz nula (también llamada matriz cero) es aquella que tienen todos sus elementos iguales a 0, ejemplo:

La forma en que se programara es de la siguiente manera:

 

* Crear una variable que sume todos los datos dentro de la matriz.

 

* Si la suma de todos los datos es igual a 0, entonces es matriz nula.

case 2:
    filas=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas de la matriz"));
    columnas=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas de la matriz"));
    matriz=new int[filas][columnas];
                        
    //Pedimos los datos
    for(int i=0;i<filas;i++){
        for(int j=0;j<columnas;j++){
            matriz[i][j]=Integer.parseInt(JOptionPane.showInputDialog("Digita un número para la posición: a["+i+"]["+j+"]"+" de la matriz A"));
            System.out.print(matriz[i][j]+" ");
        }
        System.out.println();
    }
                        
    int sum=0; //variable que sumara todos los elementos 
    for(int i=0;i<matriz.length;i++){ //Tamaño de filas
        for(int j=0;j<matriz[0].length;j++){ //Tamaño de columnas
            sum+=matriz[i][j];
        } 
    }
    if(sum==0){
        JOptionPane.showMessageDialog(null, "La matriz es nula");
    }else{
        JOptionPane.showMessageDialog(null, "La suma de los elementos es de: "+sum+", por lo tanto no es nula");
    }                   
    break;  

 

Nota: Se modificó la declaración de variables de filas, columnas y matriz de la matriz cuadrada y pasaron a ser declaradas al inicio del programa para crearlas solo una vez y reutilizar las variables para las demás operaciones; al hacer esto ahorramos memoria.

Matriz Diagonal

Una matriz diagonal es una matriz cuadrada cuyos valores por encima y debajo de la diagonal principal son 0, la diagonal principal puede contener cualquier valor, ejemplo:

case 3:
     filas=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas de la matriz"));
     columnas=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas de la matriz"));
     matriz=new int[filas][columnas];
     if(matriz.length==matriz[0].length){
                                
         //Pedimos los datos
         for(int i=0;i<filas;i++){
             for(int j=0;j<columnas;j++){
                 matriz[i][j]=Integer.parseInt(JOptionPane.showInputDialog("Digita un número para la posición: a["+i+"]["+j+"]"+" de la matriz A"));
                 System.out.print(matriz[i][j]+" ");
             }
             System.out.println();
         }
                        
         //comienza proceso de suma para verificar si la matriz es diagonal
         int sumDiag=0;
         for(int i=0;i<matriz.length;i++){
             for(int j=0;j<matriz[0].length;j++){
                 if(!(i==j)){ //Saltamos las posiciones de la diagonal, estas posiciones no necesitan ser sumadas
                    sumDiag+=matriz[i][j];
                 }
              }
          }
          if(sumDiag==0){
              JOptionPane.showMessageDialog(null, "Es diagonal!!!");
          }else{
              JOptionPane.showMessageDialog(null, "La matriz no es diagonal ya que hay valores diferentes de 0 por encima o debajo de la matriz");
          }
     }else{
        JOptionPane.showMessageDialog(null, "No es cuadrada por lo tanto no puede haber diagonal");
     }
        
     break;  

Matriz Escalar

Una matriz escalar es una matriz diagonal (y a su vez cuadrada) en la que los elementos de la diagonal principal son iguales, ejemplo: 

case 4:
     filas=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas de la matriz"));
     columnas=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas de la matriz"));
     matriz=new int[filas][columnas];
     if(matriz.length==matriz[0].length){
                                
        //Pedimos los datos
        for(int i=0;i<filas;i++){
            for(int j=0;j<columnas;j++){
                matriz[i][j]=Integer.parseInt(JOptionPane.showInputDialog("Digita un número para la posición: a["+i+"]["+j+"]"+" de la matriz A"));
                System.out.print(matriz[i][j]+" ");
            }
            System.out.println();
        }
                        
        //Verificamos si la matriz es escalar
        int sumElem=0,sumDiag=0,aux=0; 
        /*sumElem=suma de los elementos que no son la diagonal principal
         * sumDiag=suma de la diagonal principal
         * aux=variable que almacena el valor que debe tener toda la diagonal  
         */
        for(int i=0;i<matriz.length;i++){
            for(int j=0;j<matriz[0].length;j++){
                //El primer elemento de la matriz es el primer elementos de la diagonal,por lo tanto debe ser igual en toda la diagonal
                if((i==0)&&(j==0)){
                    aux=matriz[i][j];
                }
                if(!(i==j)){
                    sumElem+=matriz[i][j];
                }else if(matriz[i][j]==aux){
                        sumDiag+=aux;
                }
            }
        }//Fin de ciclos
                        
        if(sumElem==0){
            if(sumDiag/matriz.length==aux){
                JOptionPane.showMessageDialog(null, "Es matriz escalar");
            }else{
                JOptionPane.showMessageDialog(null, "No es matriz escalar, los elementos de la diagonal no son iguales");
            }
        }else{
            JOptionPane.showMessageDialog(null, "La matriz no es escalar ya que hay valores diferentes de 0 por encima o debajo de la matriz");
        }
                        
    }else{
        JOptionPane.showMessageDialog(null, "No es cuadrada por lo tanto no puede haber matriz escalar");
    }
    break;   

Código Completo utilizado:

package pqtMatricesDos;

import javax.swing.JOptionPane;

public class OperacionesMatriz {

        public static void main(String[] args) {
                int op=0;
        String menu="";
        int filas;
                int columnas;
                int matriz[][];
                
        do{
            menu="";
            menu+="******** Menú ********\n";
            menu+="1.- Matriz cuadrada \n";
            menu+="2.- Matriz Nula \n";
            menu+="3.- Matriz Diagonal \n";
            menu+="4.- Matriz Escalar \n";        
            menu+="5.- Salir \n";
            menu+="Elija una opción";
            op=Integer.parseInt(JOptionPane.showInputDialog(menu));
                        switch(op){
            case 1:
                filas=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas de la matriz"));
                        columnas=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas de la matriz"));
                        matriz=new int[filas][columnas];
                        if(matriz.length==matriz[0].length)
                                JOptionPane.showMessageDialog(null, "Si es cuadrada");
                        else
                                JOptionPane.showMessageDialog(null, "No es cuadrada");
                        
                break;
            case 2:
                filas=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas de la matriz"));
                        columnas=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas de la matriz"));
                        matriz=new int[filas][columnas];
                        
                        //Pedimos los datos
                        for(int i=0;i<filas;i++){
                                for(int j=0;j<columnas;j++){
                                        matriz[i][j]=Integer.parseInt(JOptionPane.showInputDialog("Digita un número para la posición: a["+i+"]["+j+"]"+" de la matriz A"));
                                        System.out.print(matriz[i][j]+" ");
                                }
                                System.out.println();
                        }
                        
                int sum=0; //variable que sumara todos los elementos 
                        for(int i=0;i<matriz.length;i++){ //Tamaño de filas
                                for(int j=0;j<matriz[0].length;j++){ //Tamaño de columnas
                                        sum+=matriz[i][j];
                                }
                        }
                        if(sum==0){
                                JOptionPane.showMessageDialog(null, "La matriz es nula");
                        }else{
                                JOptionPane.showMessageDialog(null, "La suma de los elementos es de: "+sum+", por lo tanto no es nula");
                        }
                        
                break;  
            case 3:
                filas=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas de la matriz"));
                        columnas=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas de la matriz"));
                        matriz=new int[filas][columnas];
                        if(matriz.length==matriz[0].length){
                                
                                //Pedimos los datos
                        for(int i=0;i<filas;i++){
                                for(int j=0;j<columnas;j++){
                                        matriz[i][j]=Integer.parseInt(JOptionPane.showInputDialog("Digita un número para la posición: a["+i+"]["+j+"]"+" de la matriz A"));
                                        System.out.print(matriz[i][j]+" ");
                                }
                                System.out.println();
                        }
                        
                        //comienza proceso de suma para verificar si la matriz es diagonal
                                int sumDiag=0;
                        for(int i=0;i<matriz.length;i++){
                                for(int j=0;j<matriz[0].length;j++){
                                        if(!(i==j)){ //Saltamos las posiciones de la diagonal, estas posiciones no necesitan ser sumadas
                                                sumDiag+=matriz[i][j];
                                        }
                                }
                        }
                        if(sumDiag==0){
                                JOptionPane.showMessageDialog(null, "Es diagonal!!!");
                        }else{
                                JOptionPane.showMessageDialog(null, "La matriz no es diagonal ya que hay valores diferentes de 0 por encima o debajo de la matriz");
                        }
                        }else{
                                JOptionPane.showMessageDialog(null, "No es cuadrada por lo tanto no puede haber diagonal");
                        }
                        
                break;  
            case 4:
                filas=Integer.parseInt(JOptionPane.showInputDialog("Digita las filas de la matriz"));
                        columnas=Integer.parseInt(JOptionPane.showInputDialog("Digita las columnas de la matriz"));
                        matriz=new int[filas][columnas];
                        if(matriz.length==matriz[0].length){
                                
                                //Pedimos los datos
                        for(int i=0;i<filas;i++){
                                for(int j=0;j<columnas;j++){
                                        matriz[i][j]=Integer.parseInt(JOptionPane.showInputDialog("Digita un número para la posición: a["+i+"]["+j+"]"+" de la matriz A"));
                                        System.out.print(matriz[i][j]+" ");
                                }
                                System.out.println();
                        }
                        
                        //Verificamos si la matriz es escalar
                        int sumElem=0,sumDiag=0,aux=0; 
                        /*sumElem=suma de los elementos que no son la diagonal principal
                         * sumDiag=suma de la diagonal principal
                         * aux=variable que almacena el valor que debe tener toda la diagonal  
                         */
                        for(int i=0;i<matriz.length;i++){
                                for(int j=0;j<matriz[0].length;j++){
                                        //El primer elemento de la matriz es el primer elementos de la diagonal,por lo tanto debe ser igual en toda la diagonal
                                        if((i==0)&&(j==0)){
                                                aux=matriz[i][j];
                                        }
                                        if(!(i==j)){
                                                sumElem+=matriz[i][j];
                                        }else if(matriz[i][j]==aux){
                                                        sumDiag+=aux;
                                        }
                                }
                        }//Fin de ciclos
                        
                        if(sumElem==0){
                                if(sumDiag/matriz.length==aux){
                                        JOptionPane.showMessageDialog(null, "Es matriz escalar");
                                }else{
                                        JOptionPane.showMessageDialog(null, "No es matriz escalar, los elementos de la diagonal no son iguales");
                                }
                        }else{
                                JOptionPane.showMessageDialog(null, "La matriz no es escalar ya que hay valores diferentes de 0 por encima o debajo de la matriz");
                        }
                        
                        }else{
                                JOptionPane.showMessageDialog(null, "No es cuadrada por lo tanto no puede haber matriz escalar");
                        }
                break;   
            }
        }while(op!=5);
        }
}