matrizPotencias

package org.ip.sesion10;

public class MatrizPotencias implements Comparable<Object> {

    private Potencia [][] matrizPotencias;

    public MatrizPotencias (int numFilas,int numColumnas) {
        matrizPotencias = new Potencia[numFilas][numColumnas];
        for (int i = 0; i < matrizPotencias.length; i++) {
            for (int j = 0; j < matrizPotencias[i].length; j++) {
                matrizPotencias[i][j] = new Potencia(i, j);
            }
        }
    }

    public MatrizPotencias(Potencia [][] matriz) {
        matrizPotencias = new Potencia[matriz.length][matriz[0].length];
        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz[i].length; j++) {
                matrizPotencias[i][j] = new Potencia(matriz[i][j]);
            }
        }
    }

    public MatrizPotencias(MatrizPotencias matrizPotencias){
        this.matrizPotencias = new Potencia[matrizPotencias.getNumeroFilas()][matrizPotencias.getNumeroColumnas()];
        for (int i = 0; i < matrizPotencias.getNumeroFilas(); i++) {
            for (int j = 0; j < matrizPotencias.getNumeroColumnas(); j++) {
                this.matrizPotencias[i][j] = new Potencia(matrizPotencias.getPotencia(i, j));
            }
        }
    }

    public Potencia [][] getMatriz(){
        return matrizPotencias;
    }

    public int getNumeroPotencias() {
        return matrizPotencias.length* matrizPotencias[0].length;
    }

    public int getNumeroFilas() {
        return matrizPotencias.length;
    }

    public int getNumeroColumnas() {
        return matrizPotencias[0].length;
    }

    public boolean tienenTodasPotenciasMismaBase() {
        int base = matrizPotencias[0][0].getBase();
        for (int i = 0; i < matrizPotencias.length; i++) {
            for (int j = 0; j < matrizPotencias[i].length; j++) {
                if (matrizPotencias[i][j].getBase() != base)
                    return false;
            }
        }

        return true;
    }

    public void setMatrizPotencia(Potencia potencia) {
        if (matrizPotencias == null)
            return;
        else {
            for (int i = 0; i < matrizPotencias.length; i++) {
                for (int j = 0; j < matrizPotencias[i].length; j++) {
                    matrizPotencias[i][j] = new Potencia(potencia);
                }
            }
        }
    }

    public Potencia getPotencia (int fila, int columna) {
        if ((fila < 0) || (fila > matrizPotencias.length - 1)) {
            throw new RuntimeException("Valor de fila fuera de rango");
        }
        if ((columna < 0) || (columna > matrizPotencias[0].length - 1)) {
            throw new RuntimeException("Valor de columna fuera de rango");
        }
        return new Potencia(matrizPotencias[fila][columna]);
    }

    public boolean setPotencia (int fila, int columna, Potencia potencia) {
        if ((fila < 0) || (fila > matrizPotencias.length - 1)) {
            return false;
        }
        if ((columna < 0) || (columna > matrizPotencias[0].length - 1)) {
            return false;
        }
        matrizPotencias[fila][columna] = new Potencia(potencia);
        return true;
    }

    public Potencia getMinimaPotencia() {
        Potencia min = matrizPotencias[0][0];
        for (int i = 0; i < matrizPotencias.length; i++) {
            for (int j = 0; j < matrizPotencias[i].length; j++) {
                if (matrizPotencias[i][j].compareTo(min) < 0)
                    min = matrizPotencias[i][j];
            }
        }
        return new Potencia(min);
    }

    public Potencia getMaximaPotencia() {
        Potencia max = matrizPotencias[0][0];
        for (int i = 0; i < matrizPotencias.length; i++) {
            for (int j = 0; j < matrizPotencias[i].length; j++) {
                if (matrizPotencias[i][j].compareTo(max) > 0)
                    max = matrizPotencias[i][j];
            }
        }
        return new Potencia(max);
    }

    public Potencia getPotenciaProductoMatriz() {
        if(!tienenTodasPotenciasMismaBase())
            throw new RuntimeException("No todas las potencias tienen la misma base");
        Potencia resultado = new Potencia(matrizPotencias[0][0].getBase(), 0);
        for (int i = 0; i < matrizPotencias.length; i++) {
            for (int j = 0; j < matrizPotencias[i].length; j++) {
                resultado =resultado.producto(matrizPotencias[i][j]);
            }
        }
        return resultado;
    }

    public double getValorSumaMatriz() {
        double suma = 0.0;
        for (int i = 0; i < matrizPotencias.length; i++) {
            for (int j = 0; j < matrizPotencias[i].length; j++) {
                suma = suma + matrizPotencias[i][j].getValor();
            }
        }
        return suma;
    }

    public boolean busquedaPotencia(Potencia potencia) {
        for (int i = 0; i < matrizPotencias.length ; i++) {
            for (int j = 0; j < matrizPotencias[i].length; j++) {
                if (matrizPotencias[i][j].equals(potencia))
                    return true;
            }
        }
        return false;
    }

    private void insercion(Potencia [] array) {
        for (int i = 1; i < array.length; i++) {
            Potencia aux = array[i];
            int j;
            for (j = i - 1; (j >= 0) && (aux.compareTo(array[j]) < 0); j--) {
                array [j + 1] = array[j];
            }
            array[j + 1] = aux;
        }
    }

    public void ordenacionMatriz() {
        Potencia [] array = new Potencia[this.getNumeroPotencias()];
        int k = 0;
        for (int i = 0; i < matrizPotencias.length; i++) {
            for(int j = 0; j < matrizPotencias[i].length; j++) {
                array[k] = new Potencia(matrizPotencias[i][j]);
                k++;
            }
        }
        insercion(array);
        k = 0;
        for (int i = 0; i < matrizPotencias.length; i++) {
            for (int j = 0; j < matrizPotencias[i].length; j++) {
                matrizPotencias[i][j] = array[k];
                k++;
            }
        }
    }

    @Override
    public String toString() {
        String salida = "Matriz Potencias:\n";
        for (int i = 0; i < matrizPotencias.length; i++) {
            for (int j = 0; j < matrizPotencias[i].length; j++) {
                if (j != matrizPotencias[i].length - 1)
                    salida += matrizPotencias[i][j].toString() + "  ";
                else
                    salida += matrizPotencias[i][j].toString();
            }
            if (i != matrizPotencias.length - 1)
                salida += "\n";
        }
        return salida;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        if (!(obj instanceof MatrizPotencias))
            return false;
        MatrizPotencias otraMatriz = (MatrizPotencias) obj;

        if (this.getNumeroPotencias() != otraMatriz.getNumeroPotencias())
            return false;
        boolean equal = true;
        for (int i = 0; i < matrizPotencias.length && equal; i++) {
            for (int j = 0; j < matrizPotencias[i].length && equal; j++){
                if (!matrizPotencias[i][j].equals(otraMatriz.getPotencia(i, j)))
                    equal = false;
            }
        }
        return equal;
    }

    @Override
    public int compareTo(Object obj) {
        MatrizPotencias otraMatriz = (MatrizPotencias) obj;

        if (this.getValorSumaMatriz() > otraMatriz.getValorSumaMatriz()) {
            return 1;
        }
        if (this.getValorSumaMatriz() < otraMatriz.getValorSumaMatriz()) {
            return -1;
        }
        else
            return 0;
    }
}