Clase Matriz

package matriz;

public class Matriz {

    private double matriz[][];
    private int fila;
    private int columna;

    public Matriz( int fila, int columna ){
        if( fila >= 0 )
            this.fila = fila;
        else
            this.fila = 1;
        if( columna >= 0 )
            this.columna = columna;
        else
            this.columna = 1;
        matriz = new double[ this.fila ][ this.columna ];
    }

    public Matriz( Matriz m ){
        if ( m != null ){
            this.fila = m.getFila();
            this.columna = m.getColumna();
            matriz = new double[ m.getFila() ][ m.getColumna() ];
        }else{
            this.fila = 1;
            this.columna = 1;
            matriz = new double[ 1 ][ 1 ];
        }
    }

    public void iniciarRandom(){
        for( int i = 0; i < matriz.length; i++ ){
            for( int j = 0; j < matriz[ i ].length; j++ ){
                matriz[ i ][ j ] = ( int ) ( Math.random() * 5 );
            }
        }
    }

    public String dimension(){
        return ( fila + " x " + columna );
    }

    public int orden(){
        if ( esCuadrada() )
            return this.fila;
        return 0;
    }

    public boolean esIgual( Matriz m ){
        if( this.fila != m.getFila() || this.columna != m.getColumna() )
            return false;
        for( int i = 0; i < matriz.length; i++ ){
            for( int j = 0; j < matriz[ i ].length; j++ ){
                if( matriz[ i ][ j ] != m.matriz[ i ][ j ]){
                    return false;
                }
            }
        }
        return true;
    }

    public String tipo(){
        if ( esVectorFila() )
            return "Matriz Fila";
        if ( esVectorColumna() )
            return "Matriz Columna";
        if ( orden() == 0 )
            return "Matriz Rectangular";
        if ( esVacia() )
            return "Matriz Nula";
        String frase = "Matriz Cuadrada";
        if( esCuadrada() ){
            if ( esIdentidad() )
                frase += ", Identidad";
            else if ( esEscalar() )
                frase += ", Escalar";
            else if ( esDiagonal() )
                frase += ", Diagonal";
            else if ( esTriangularSuperior( ) )
                frase += ", Triangular Superior";
            else if ( esTriangularInferior() )
                frase += ", Triangular Inferior";

            if ( esSimetrica() )
                frase += ", Simetrica";
            else if ( esAntisimetrica() )
                frase += ", AntiSimetrica";

            if ( esIdempotente())
                frase += ", Idempotente";

            if ( this.esInvolutiva() )
                frase += ", Involutiva";

            if ( esOrtogonal() )
                frase += ", Ortogonal";
            return frase;
        }
        return "No encontrado";
    }

    public boolean esVacia(){
        for( int i = 0; i < matriz.length; i++ ){
            for( int j = 0; j < matriz[ j ].length; j++ ){
                if( matriz[ i ][ j ] != 0 )
                    return false;
            }
        }
        return true;
    }

    public boolean esVectorFila(){
        return ( fila == 1 );
    }

    public boolean esVectorColumna(){
        return ( columna == 1 );
    }

    public boolean esCuadrada(){
        return ( fila == columna );
    }
    /*
    SI ES CUADRADA!!!!
    */

    public boolean esTriangularInferior(){
        if( !esCuadrada() )
            return false;
        for( int i = 0; i < matriz.length; i++ ){
            for( int j = ( i + 1 ); j < matriz[ i ].length; j++ ){
                if ( matriz[ i ][ j ] != 0 )
                    return false;
            }
        }
        return true;
    }

    public boolean esTriangularSuperior(){
        if( !esCuadrada() )
            return false;
        for( int i = 1; i < matriz.length; i++ ){
            for( int j = 0; j < i; j++ ){
                if ( matriz[ i ][ j ] != 0 )
                    return false;
            }
        }
        return true;
    }

    public boolean esDiagonal(){
        return ( esTriangularSuperior() && esTriangularInferior() );
    }

    //matriz diagonal pero todos los de la diagonal iguales
    public boolean esEscalar(){
        if ( !esDiagonal() )
            return false;
        double elemento = matriz[ 0 ][ 0 ];
        for( int i = 1; i < matriz.length; i++ ){
            if ( elemento != matriz[ i ][ i ] )
                return false;
            elemento = matriz[ i ][ i ];
        }
        return true;
    }
    //matriz diagonal pero todos los de la diagonal son 1
    public boolean esIdentidad(){
        if ( !esEscalar() )
            return false;
        return ( matriz[ 0 ][ 0 ] == 1 );
    }

    //si tiene inversa
    public boolean esRegular(){
        return ( determinante() != 0.0 );
    }
    //si no tiene inversa
    public boolean esSingular(){
        return !esRegular();
    }
    //Si A^2 = A
    public boolean esIdempotente(){
        if ( !esCuadrada() )
            return false;
        Matriz m = copiar();
        m.producto( m );
        return ( m.esIgual( this ) );
    }
    // A^2 = I
    public boolean esInvolutiva(){
        if ( !esCuadrada() )
            return false;
        Matriz m = copiar();
        m.producto( m );
        return ( m.esIgual( m.getIdentidad() ) );
    }

    // A = A^t
    public boolean esSimetrica(){
        Matriz t = copiar();
        t.traspuesta();
        return ( t.esIgual( this ) );
    }
    // A = - A ^t
    public boolean esAntisimetrica(){
        Matriz t = copiar();
        t.traspuesta();
        t.producto( -1.0 );
        return ( t.esIgual( this ) );
    }

    // A * A^t = I
    public boolean esOrtogonal(){
        Matriz t = copiar();
        Matriz a = copiar();
        t.traspuesta();
        a.producto( t );
        return ( a.esIgual( a.getIdentidad() ) );

    }

    /*
    FIN SI ES CUADRADA!!!
    */

    public void traspuesta(){
        double copiaMatriz[][] = matriz;
        setDimension( columna, fila );

        for( int i = 0; i < copiaMatriz.length; i++ ){
            for( int j = 0; j < copiaMatriz[ i ].length; j++ ){
                matriz[ j ][ i ] = copiaMatriz[ i ][ j ];
            }
        }
    }

    /* FALTA: */
    public int rango(){
        return 0;
    }

    public double determinante(){
        if ( !esCuadrada() ){
            System.err.println( "No se puede calcular determinante" );
            return 0.0;
        }
        return 0.0;
    }
    /* FIN FALTA */

    public Matriz copiar( ){
        Matriz m;
        m = new Matriz( fila, columna );
        for( int i = 0; i < matriz.length; i++ ){
            for( int j = 0; j < matriz[ i ].length; j++ ){
                m.matriz[ i ][ j ] = matriz[ i ][ j ];
            }
        }
        return m;
    }

    public void copiar( Matriz m ){
        setDimension( m.getFila(), m.getColumna() );
        for( int i = 0; i < matriz.length; i++ ){
            for( int j = 0; j < matriz[ i ].length; j++ ){
                matriz[ i ][ j ] = m.matriz[ i ][ j ];
            }
        }
    }

    //Puede devolverse otra Matriz igual a gusto de uno.
    public void sumar( Matriz m ){
        if( fila != m.getFila() || columna != m.getColumna() ){
            System.err.println( "No puede sumarse" );
        }else{
            for( int i = 0; i < matriz.length; i++ ){
                for( int j = 0; j < matriz[ i ].length; j++ ){
                    matriz[ i ][ j ] += m.getMatriz()[ i ][ j ];
                }
            }
        }
    }

    //Puede devolverse otra Matriz igual a gusto de uno.
    public void restar( Matriz m ){
        if( fila != m.getFila() || columna != m.getColumna() ){
            System.err.println( "No puede restarse" );
        }else{
            for( int i = 0; i < matriz.length; i++ ){
                for( int j = 0; j < matriz[ i ].length; j++ ){
                    matriz[ i ][ j ] -= m.getMatriz()[ i ][ j ];
                }
            }
        }
    }

    public void producto( double escalar ){
        //Evita multiplicar uno a cada uno ( mismo resultado )
        if ( escalar != 1.0 ){
            for( int i = 0; i < matriz.length; i++ ){
                for( int j = 0; j < matriz[ i ].length; j++ ){
                    matriz[ i ][ j ] *= escalar;
                }
            }
        }
    }

    public void producto( Matriz m ){
        if ( columna != m.getFila() ){
            System.err.println( "No pueden multiplicarse" );
        }else{
            double copiaMatriz[][] = matriz;
            setDimension( fila, m.getColumna() );
            double suma;
            //Para cada fila de A
            for( int i = 0; i < copiaMatriz.length; i++ ){
                //Para cada columna de B
                for( int j = 0; j < m.getColumna(); j++ ){
                    suma = 0.0;
                    //Se multiplica la fila A por las cada columna de B
                    for( int k = 0; k < m.getFila(); k++ ){
                       suma = suma + copiaMatriz[ i ][ k ] * m.matriz[ k ][ j ];
                    }
                    matriz[ i ][ j ] = suma;
                }
            }
        }
    }

    public void ordenarFila( int fila ){
        if( verificarFila( fila ) ){
            double aux = 0;
            for( int i = 0; i < columna - 1 ; i++ ){
                for( int j = ( i + 1 ); j < columna; j++ ){
                    if ( matriz[ fila ][ i ] > matriz[ fila ][ j ] ){
                        aux = matriz[ fila ][ i ];
                        matriz[ fila ][ i ] = matriz[ fila ][ j ];
                        matriz[ fila ][ j ] = aux;
                    }
                }
            }
        }
    }

    public void ordenarColumna( int columna ){
        if( verificarColumna( columna ) ){
            double aux;
            for( int i = 0; i < fila - 1 ; i++ ){
                for( int j = ( i + 1 ); j < fila; j++ ){
                    if ( matriz[ i ][ columna ] > matriz[ j ][ columna ] ){
                        aux = matriz[ i ][ columna ];
                        matriz[ i ][ columna ] = matriz[ j ][ columna ];
                        matriz[ j ][ columna ] = aux;
                    }
                }
            }
        }
    }

    public void ordenarMatriz( ){
        double aux;
        //Para cada dato:
        for( int i = 0; i < fila; i++ ){
            for( int j = 0; j < columna; j++ ){
                //Se busca el menor y se cambian
                for( int x = 0; x < fila; x++ ){
                    for( int y = 0; y < columna; y++ ){
                        if ( matriz[ i ][ j ] < matriz[ x ][ y ] ){
                            aux = matriz[ i ][ j ];
                            matriz[ i ][ j ] = matriz[ x ][ y ];
                            matriz[ x ][ y ]= aux;
                        }
                    }
                }
            }
        }
    }

    public double sumarFila( int fila ){
        double suma = 0.0;
        if ( verificarFila( fila ) ){
            for( int j = 0; j < columna; j++ )
                suma += matriz[ fila ][ j ];

        }
        return suma;
    }

    public double sumarColumna( int columna ){
        double suma = 0.0;
        if ( verificarColumna( columna ) ){
            for( int i = 0; i < columna; i++ )
                suma += matriz[ i ][ columna ];

        }
        return suma;
    }

    public double sumarTotal( ){
        double suma = 0.0;
        for( int i = 0; i < fila; i++ ){
            for( int j = 0; j < columna; j++ ){
                suma += matriz[ i ][ j ];
            }
        }
        return suma;
    }

    public boolean existeValor( int valor ){
        for( int i = 0; i < fila; i++ ){
            for( int j = 0; j < columna; j++ ){
                if( matriz[ i ][ j ] == valor )
                    return true;
            }
        }
        return false;
    }

    public int vecesExiste( int valor ){
        int veces = 0;
        if ( existeValor( valor ) ){
            for( int i = 0; i < fila; i++ ){
                for( int j = 0; j < columna; j++ ){
                    if( matriz[ i ][ j ] == valor )
                        veces++;
                }
            }
        }
        return veces;
    }

    public void insertarElemento( int elemento, int fila, int columna ){
        if ( verificarFila( fila ) && verificarColumna( columna ) ){
            matriz[ fila ][ columna ] = elemento;
        }
    }

    public void eliminarElemento( int elemento, int fila, int columna ){
        if ( verificarFila( fila ) && verificarColumna( columna ) ){
            matriz[ fila ][ columna ] = 0.0;
        }
    }

    public void vaciarMatriz(){
        matriz = new double[ fila ][ columna ];
    }

    public void cambiarFilas( int fila1, int fila2 ){
        if ( verificarFila( fila1 ) && verificarFila( fila2 ) ){
            double aux;
            for( int j = 0; j < columna; j++ ){
                aux = matriz[ fila1 ][ j ];
                matriz[ fila1 ][ j ] = matriz[ fila2 ][ j ];
                matriz[ fila2 ][ j ] = aux;
            }
        }else{
            System.err.println( "No pueden intercambiarse" );
        }
    }

    public void cambiarColumnas( int columna1, int columna2 ){
        if ( verificarColumna( columna1 ) && verificarColumna( columna2 ) ){
            double aux;
            for( int i = 0; i < fila; i++ ){
                aux = matriz[ i ][ columna1 ];
                matriz[ i ][ columna1 ] = matriz[ i ][ columna2 ];
                matriz[ i ][ columna2 ] = aux;
            }
        }else{
            System.err.println( "No pueden intercambiarse" );
        }
    }

    public void insertarFila(){
        insertarFilas( 1 );
    }

    public void insertarFilas( int n ){
        if ( n > 0 )
            setDimension( fila + n, columna );
    }

    public void insertarColumna(){
        insertarColumnas( 1 );
    }

    public void insertarColumnas( int n ){
        setDimension( fila, columna + n );
    }

    public void eliminarFila(){
        eliminarFilas( 1 );
    }

    public void eliminarFilas( int n ){
        setDimension( fila - n, columna);
    }

    public void eliminarColumna(){
        eliminarColumnas( 1 );
    }

    public void eliminarColumnas( int n ){
        setDimension( fila, columna - n );
    }

    public double[][] getMatriz() {
        return matriz;
    }

    public void setMatriz( double[][] matriz ) {
        this.matriz = matriz;
    }

    public void setDimension( int fila, int columna ){
        if ( fila > 0 )
            this.fila = fila;
        if( columna > 0 )
            this.columna = columna;

        double copiaMatriz[][] = matriz;
        matriz = new double[ this.fila ][ this.columna ];
        for( int i = 0; i < copiaMatriz.length; i++ ){
            for( int j = 0; j < copiaMatriz[ i ].length; j++ ){
                if ( i < this.fila && j < this.columna )
                    matriz[ i ][ j ] = copiaMatriz[ i ][ j ];
            }
        }

    }

    public Matriz getIdentidad(){
        Matriz identidad = new Matriz( fila, columna );
        for( int i = 0; i < fila; i++ )
            identidad.matriz[ i ][ i ] = 1;
        return identidad;
    }

    public double[] getVectorFila( int fila ){
        if ( verificarFila( fila ) )
            return matriz[ fila ];
        return null;
    }

    public double[] getVectorColumna( int columna ){
        if( verificarColumna( columna ) ){
            double vector[] = new double[ this.fila ];
            for( int i = 0; i < vector.length; i++ )
                vector[ i ] = matriz[ i ][ columna ];
            return vector;
        }
        return null;
    }

    public boolean verificarColumna( int columna ){
        return ( columna >= 0 && columna < this.columna );
    }

    public boolean verificarFila( int fila ){
        return ( fila >= 0 && fila < this.fila );
    }


    public int getFila() {
        return fila;
    }

    public void setFila(int fila) {
        if ( fila > 0 )
            this.fila = fila;
    }

    public int getColumna() {
        return columna;
    }

    public void setColumna(int columna) {
        if ( columna > 0 )
            this.columna = columna;
    }

    public void imprimir(){
        System.out.println();
        for( int i = 0; i < matriz.length; i++ ){
            for( int j = 0; j < matriz[ i ].length; j++ ){
                System.out.print( matriz[ i ][ j ] + "  " );
            }
            System.out.println();
        }
        System.out.println();
    }

    @Override
    public String toString(){
        return ( "Tipo: " + tipo() + ", Dimension: " + dimension() +
                ", Orden: " + orden() );
    }


}