import java.awt.*;
import javax.swing.*;
import java.text.*;

public class GElim extends JFrame {
    
    /** Crea un nuevo formulario GElim */
    public GElim() {
        initComponents();
        initMatrixDisplay(3,4);
        model = new Model();
    }
    
    public void initMatrixDisplay(int i, int j){
        matrixDisplay = new MatrixDisplay(i,j);
        getContentPane().add(matrixDisplay, BorderLayout.CENTER);
        pack();
    }
    
    /** Este método es llamado desde el constructor para
     * inicializar el formulario.
     * ADVERTENCIA: NO modifique este código. El contenido de este método
     * siempre se regenera desde el Editor de formularios.
     */
    private void initComponents() {
        bottomPanel = new javax.swing.JPanel();
        outputPanel = new javax.swing.JPanel();
        ouputLabel = new javax.swing.JLabel();
        controlPanel = new javax.swing.JPanel();
        pivotButton = new javax.swing.JButton();
        backSolveButton = new javax.swing.JButton();
        divideButton = new javax.swing.JButton();
        solveButton = new javax.swing.JButton();
        swapRow = new javax.swing.JPanel();
        swapLabel1 = new javax.swing.JLabel();
        swapText1 = new javax.swing.JTextField();
        swapLabel2 = new javax.swing.JLabel();
        swapText2 = new javax.swing.JTextField();
        swapButton = new javax.swing.JButton();
        rowOperationPanel = new javax.swing.JPanel();
        rowOperationLabel1 = new javax.swing.JLabel();
        mult1Text = new javax.swing.JTextField();
        jLabel2 = new javax.swing.JLabel();
        rowOperation1Text = new javax.swing.JTextField();
        plusLabel = new javax.swing.JLabel();
        mult2Text = new javax.swing.JTextField();
        jLabel4 = new javax.swing.JLabel();
        rowOperation2Text = new javax.swing.JTextField();
        rowOperationButton = new javax.swing.JButton();
        topPanel = new javax.swing.JPanel();
        buttonHolder = new javax.swing.JPanel();
        numEquLabel = new javax.swing.JLabel();
        numEquText = new javax.swing.JTextField();
        setupButton = new javax.swing.JButton();
        editPanel = new javax.swing.JPanel();
        undoButton = new javax.swing.JButton();
        saveButton = new javax.swing.JButton();
        loadButton = new javax.swing.JButton();
        demoButton = new javax.swing.JButton();
        quitButton = new javax.swing.JButton();
        
        setTitle("Sistemas de ecuaciones lineales");
        addWindowListener(new java.awt.event.WindowAdapter() {
            public void windowClosing(java.awt.event.WindowEvent evt) {
                exitForm(evt);
            }
        });
        
        bottomPanel.setLayout(new java.awt.GridLayout(4, 0));
        
        outputPanel.setBorder(new javax.swing.border.EtchedBorder(null, java.awt.Color.black));
        outputPanel.setBackground(java.awt.Color.white);
        outputPanel.add(ouputLabel);
        
        bottomPanel.add(outputPanel);
        
        pivotButton.setToolTipText("Realiza una resolución directa reduciendo a 0 todas las celdas por debajo de la seleccionada");
        pivotButton.setText("Pivot en la selección");
        pivotButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                pivotButtonActionPerformed(evt);
            }
        });
        
        controlPanel.add(pivotButton);
        
        backSolveButton.setToolTipText("Sustituye el valor de la celda seleccionada en las filas superiores.");
        backSolveButton.setText("Sust. inversa en la selección");
        backSolveButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                backSolveButtonActionPerformed(evt);
            }
        });
        
        controlPanel.add(backSolveButton);
        
        divideButton.setToolTipText("Divide toda la fila entre el valor de la celda seleccionada");
        divideButton.setText("Dividir por la selección");                                                    
        divideButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                divideButtonActionPerformed(evt);
            }
        });
        
        controlPanel.add(divideButton);
        
        solveButton.setToolTipText("Reduce la matriz a un \"formulario escalonado de fila reducida\"");          
        solveButton.setText("Resolver");                                                                        
        solveButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                solveButtonActionPerformed(evt);
            }
        });
        
        controlPanel.add(solveButton);
        
        bottomPanel.add(controlPanel);
        
        swapLabel1.setText("Cambiar filas:");
        swapRow.add(swapLabel1);
        
        swapText1.setColumns(3);
        swapRow.add(swapText1);
        
        swapLabel2.setText("y");
        swapRow.add(swapLabel2);
        
        swapText2.setColumns(3);
        swapRow.add(swapText2);
        
        swapButton.setToolTipText("Cambia la primera fila con nombre por la segunda");
        swapButton.setText("Cambiar");
        swapButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                swapButtonActionPerformed(evt);
            }
        });
        
        swapRow.add(swapButton);
        
        bottomPanel.add(swapRow);
        
        rowOperationLabel1.setText("Operación de filas:");
        rowOperationPanel.add(rowOperationLabel1);
        
        mult1Text.setColumns(4);
        rowOperationPanel.add(mult1Text);
        
        jLabel2.setText("Fila x");
        rowOperationPanel.add(jLabel2);
        
        rowOperation1Text.setColumns(3);
        rowOperationPanel.add(rowOperation1Text);
        
        plusLabel.setText("+");
        rowOperationPanel.add(plusLabel);
        
        mult2Text.setColumns(4);
        rowOperationPanel.add(mult2Text);
        
        jLabel4.setText("Fila x");
        rowOperationPanel.add(jLabel4);
        
        rowOperation2Text.setColumns(3);
        rowOperationPanel.add(rowOperation2Text);
        
        rowOperationButton.setToolTipText("O multiplica una fila por una constante o sustituye la primera fila con nombre por una combinación con la segunda ");
        rowOperationButton.setText("Realizar");                                                         
        rowOperationButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                rowOperationButtonActionPerformed(evt);
            }
        });
        
        rowOperationPanel.add(rowOperationButton);
        
        bottomPanel.add(rowOperationPanel);
        
        getContentPane().add(bottomPanel, java.awt.BorderLayout.SOUTH);
        
        topPanel.setLayout(new java.awt.GridLayout(3, 0));
        
        numEquLabel.setText("Número de variables y ecuaciones");
        buttonHolder.add(numEquLabel);
        
        numEquText.setColumns(3);
        buttonHolder.add(numEquText);
        
        setupButton.setToolTipText("Construye una matriz NxN, siendo N = número de variables = número de ecuaciones");
        setupButton.setText("Instalación");
        setupButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                setupButtonActionPerformed(evt);
            }
        });
        
        buttonHolder.add(setupButton);
        
        topPanel.add(buttonHolder);
        
        undoButton.setToolTipText("Invierte la acción anterior");
        undoButton.setText("Deshacer");
        undoButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                undoButtonActionPerformed(evt);
            }
        });
        
        editPanel.add(undoButton);
        
        saveButton.setToolTipText("Guarda la matriz actual.");
        saveButton.setText("Guardar");
        saveButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                saveButtonActionPerformed(evt);
            }
        });
        
        editPanel.add(saveButton);
        
        loadButton.setToolTipText("Carga la matriz guardada");
        loadButton.setText("Cargar");
        loadButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                loadButtonActionPerformed(evt);
            }
        });
        
        editPanel.add(loadButton);
        
        demoButton.setToolTipText("Carga la matriz guardada previamente");
        demoButton.setText("Demo");
        demoButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                demoButtonActionPerformed(evt);
            }
        });
        
        editPanel.add(demoButton);
        
        quitButton.setToolTipText("Cierra el programa");
        quitButton.setText("Salir");
        quitButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                quitButtonActionPerformed(evt);
            }
        });
        
        editPanel.add(quitButton);
        
        topPanel.add(editPanel);
        
        getContentPane().add(topPanel, java.awt.BorderLayout.NORTH);
        
        pack();
    }
    
    private void backSolveButtonActionPerformed(java.awt.event.ActionEvent evt) {
        try{
            
            model.setCurrentMatrix(matrixDisplay.getMatrix());
            
            if(model.backSolve_check1(matrixDisplay.getCurrentCol()) ) //la selección pertenece a la matriz b                
                ouputLabel.setText("No es posible sustituir en b. Necesita seleccionar una celda en A");
            else{
                
                if(model.backSolve_check2(matrixDisplay.getCurrentRow(), matrixDisplay.getCurrentCol()))
                    // la selección no es la única x distinta de cero de la fila                                                     
                    ouputLabel.setText("El valor de x" + matrixDisplay.getCurrentCol()+ " sigue siendo desconocido. No es posible la sustitución inversa.");
                else{
                    model.backSolve_selection(matrixDisplay.getCurrentRow(), matrixDisplay.getCurrentCol());
                    matrixDisplay.setMatrix(model.getCurrentMatrix());
                    ouputLabel.setText("");
                }
            }
        }
        catch(IllegalArgumentException e){
            ouputLabel.setText("No es posible la resolución inversa en un 0");
        }
    }
    
    private void quitButtonActionPerformed(java.awt.event.ActionEvent evt) {
        System.exit(0);
    }
    
    private void demoButtonActionPerformed(java.awt.event.ActionEvent evt) {
        Matrix demoMatrix = model.getDemoMatrix();
        
        if(demoMatrix != null){
            getContentPane().remove(matrixDisplay);
            matrixDisplay = new MatrixDisplay(demoMatrix.getNumRows(), demoMatrix.getNumCols());
            getContentPane().add(matrixDisplay, BorderLayout.CENTER);
            pack();
            matrixDisplay.setMatrix(demoMatrix);
            ouputLabel.setText("Demo cargada");
        }
        else{
            ouputLabel.setText("No hay demo disponible");
        }
    }
    
    private void loadButtonActionPerformed(java.awt.event.ActionEvent evt) {
        Matrix savedMatrix = model.getSavedMatrix();
        
        if(savedMatrix != null){
            getContentPane().remove(matrixDisplay);
            matrixDisplay = new MatrixDisplay(savedMatrix.getNumRows(), savedMatrix.getNumCols());
            getContentPane().add(matrixDisplay, BorderLayout.CENTER);
            pack();
            matrixDisplay.setMatrix(savedMatrix);
            ouputLabel.setText("Matriz cargada");
        }
        else{
            ouputLabel.setText("No se ha guardado nada");
        }
    }
    
    private void saveButtonActionPerformed(java.awt.event.ActionEvent evt) {
        model.setSavedMatrix(matrixDisplay.getMatrix());
        ouputLabel.setText("Matriz guardada");
    }
    
    private void undoButtonActionPerformed(java.awt.event.ActionEvent evt) {
        Matrix previousMatrix = model.getPreviousMatrix();
        if(previousMatrix != null){
            matrixDisplay.setMatrix(previousMatrix);
            ouputLabel.setText("");
        }
        else{
            ouputLabel.setText("No hay nada para deshacer");
        }
    }
    
    private void rowOperationButtonActionPerformed(java.awt.event.ActionEvent evt) {
        int row1 = 1,row2 =1;
        double mult1=1, mult2=0;
        boolean flag = true;
        
        try{
            row1 = Integer.parseInt(rowOperation1Text.getText());
        }
        catch(NumberFormatException e){flag = false; ouputLabel.setText("Row Undefined");        }
        
        try{
            if((rowOperation2Text.getText()).equals(""))
                row2=1;
            else
                row2 = Integer.parseInt(rowOperation2Text.getText());
            
        }
        catch(NumberFormatException e){ouputLabel.setText("Entrada no válida"); flag = false;}
        
        try{
            if((mult1Text.getText()).equals(""))
                mult1=1;
            else
                mult1 = Double.parseDouble(mult1Text.getText());
        }
        catch(NumberFormatException e){ flag = false; ouputLabel.setText("Entrada no válida");}
        
        try{
            if((mult2Text.getText()).equals(""))
                mult2=0;
            else
                mult2 = Double.parseDouble(mult2Text.getText());
            
        }
        catch(NumberFormatException e){ flag = false; ouputLabel.setText("Entrada no válida");}
        
        if(flag){
            try{
                model.setCurrentMatrix(matrixDisplay.getMatrix());
                model.row_operation(row1-1,mult1,row2-1,mult2);
                matrixDisplay.setMatrix(model.getCurrentMatrix());
                ouputLabel.setText("");
            }
            catch(IllegalArgumentException e){
                ouputLabel.setText("Número de filas no válido");
            }
        }
    }
    
    private void swapButtonActionPerformed(java.awt.event.ActionEvent evt) {
        try{
            int row1 = Integer.parseInt(swapText1.getText());
            int row2 = Integer.parseInt(swapText2.getText());
            if(row1 <=0 || row2<=0)
                ouputLabel.setText("Introduzca enteros mayores que 0");
            else{
                model.setCurrentMatrix(matrixDisplay.getMatrix());
                model.swap_rows(row1-1, row2-1);
                matrixDisplay.setMatrix(model.getCurrentMatrix());
                ouputLabel.setText("");
            }
        }
        catch(IllegalArgumentException e){
            ouputLabel.setText("Número de filas no válido");
        }
    }
    
    private void divideButtonActionPerformed(java.awt.event.ActionEvent evt) {
        try{
            model.setCurrentMatrix(matrixDisplay.getMatrix());
            model.divide_selection(matrixDisplay.getCurrentRow(), matrixDisplay.getCurrentCol());
            matrixDisplay.setMatrix(model.getCurrentMatrix());
            ouputLabel.setText("");
        }
        catch(IllegalArgumentException e){
            ouputLabel.setText("No es posible dividir por 0");
        }
    }
    
    private void pivotButtonActionPerformed(java.awt.event.ActionEvent evt) {
        try{
            model.setCurrentMatrix(matrixDisplay.getMatrix());
            model.pivot_selection(matrixDisplay.getCurrentRow(), matrixDisplay.getCurrentCol());
            matrixDisplay.setMatrix(model.getCurrentMatrix());
            ouputLabel.setText("");
        }
        catch(IllegalArgumentException e){
            ouputLabel.setText("No es posible un pivot en 0");
        }
    }
    
    private void solveButtonActionPerformed(java.awt.event.ActionEvent evt) {
        try{
            model.setCurrentMatrix(matrixDisplay.getMatrix());
            matrixDisplay.setMatrix(model.solve());
            ouputLabel.setText("Matriz resuelta");
        }
        catch(NumberFormatException e){
            ouputLabel.setText("Matriz resuelta");
        }
    }
    
    
    private void setupButtonActionPerformed(java.awt.event.ActionEvent evt) {
        try{
            int numEqu = Integer.parseInt(numEquText.getText());
            int numUnk = numEqu+1;
            if(numEqu <1 || numUnk<1)
                ouputLabel.setText("Introduzca un entero mayor que 1");
            else{
                getContentPane().remove(matrixDisplay);
                matrixDisplay = new MatrixDisplay(numEqu, numUnk);
                getContentPane().add(matrixDisplay, BorderLayout.CENTER);
                pack();
                ouputLabel.setText("");
                model.reset(numEqu,numUnk);
            }
        }
        catch(NumberFormatException e){
            ouputLabel.setText("Introduzca enteros mayores que 1");
        }
        
    }
    
    private void exitForm(java.awt.event.WindowEvent evt) {
        System.exit(0);
    }
    
    public static void main(String args[]) {
        new GElim().show();
    }
    
    // Declaración de variables: no las modifique
    private javax.swing.JPanel bottomPanel;
    private javax.swing.JPanel outputPanel;
    private javax.swing.JLabel ouputLabel;
    private javax.swing.JPanel controlPanel;
    private javax.swing.JButton pivotButton;
    private javax.swing.JButton backSolveButton;
    private javax.swing.JButton divideButton;
    private javax.swing.JButton solveButton;
    private javax.swing.JPanel swapRow;
    private javax.swing.JLabel swapLabel1;
    private javax.swing.JTextField swapText1;
    private javax.swing.JLabel swapLabel2;
    private javax.swing.JTextField swapText2;
    private javax.swing.JButton swapButton;
    private javax.swing.JPanel rowOperationPanel;
    private javax.swing.JLabel rowOperationLabel1;
    private javax.swing.JTextField mult1Text;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JTextField rowOperation1Text;
    private javax.swing.JLabel plusLabel;
    private javax.swing.JTextField mult2Text;
    private javax.swing.JLabel jLabel4;
    private javax.swing.JTextField rowOperation2Text;
    private javax.swing.JButton rowOperationButton;
    private javax.swing.JPanel topPanel;
    private javax.swing.JPanel buttonHolder;
    private javax.swing.JLabel numEquLabel;
    private javax.swing.JTextField numEquText;
    private javax.swing.JButton setupButton;
    private javax.swing.JPanel editPanel;
    private javax.swing.JButton undoButton;
    private javax.swing.JButton saveButton;
    private javax.swing.JButton loadButton;
    private javax.swing.JButton demoButton;
    private javax.swing.JButton quitButton;
    // Fin de la declaración de variables
    private MatrixDisplay matrixDisplay;
    private int currentRow;
    private int currentCol;
    Model model;
}

class Gauss{
    
    public static void gaussian(Matrix a, Matrix b,  Matrix x) {
        int i, j, n;
        n= a.getNumRows();               // Número de incógnitas
        Matrix q= new Matrix(n, n+1);
        for (i=0; i < n; i++) {
            for (j=0; j < n; j++)        // Forma la matriz q
                // q(i,j)= a(i,j)
                q.setElement(i, j, a.getElement(i, j));
            // q(i,n)= b(i,0)
            q.setElement(i, n, b.getElement(i, 0));
        }
        forward_solve(q);          // Realiza la eliminación gaussiana
        back_solve(q);             // Realiza la sustitución inversa
        
        for (i=0; i<n; i++)
            // x(i,0)= q(i,n)
            x.setElement(i, 0, q.getElement(i, n));
    }
    
    public static void gaussian(Matrix a,  Matrix x) {
        int i, j, n, c;
        n= a.getNumRows();               // Número de incógnitas
        c= a.getNumCols();
        
        Matrix q= new Matrix(n, c);
        for (i=0; i < n; i++) {
            for (j=0; j < c; j++)        // Forma la matriz q
                // q(i,j)= a(i,j)
                q.setElement(i, j, a.getElement(i, j));
        }
        
        forward_solve(q);          // Realiza la eliminación gaussiana
        back_solve(q);             // Realiza la sustitución inversa
        
        for (i=0; i<n; i++)
            // x(i,0)= q(i,n)
            x.setElement(i, 0, q.getElement(i, n));
    }
    
    private static void forward_solve(Matrix q) {
        int i, j, k, maxr, n;
        double t, pivot;
        n= q.getNumRows();
        
        for (i=0; i < n; i++) {  // Busca el número de filas con EL elemento máximo en esta
            maxr= i;		// columna, en la diagonal o por debajo de ella
            for (j= i+1; j < n; j++)
                if (Math.abs(q.getElement(j,i)) >Math.abs(q.getElement(maxr,i)))
                    maxr= j;
            if (maxr != i)		// Si la fila no es la actual, cambia a otra
                for (k=i; k <= n; k++)
                { t= q.getElement(i,k);        // t= q(i,k)
                  // q(i,k)= q(maxr, k)
                  q.setElement(i,k, q.getElement(maxr, k));
                  q.setElement(maxr, k, t);    // q(maxr, k)= t
                }
            for (j= i+1; j <n; j++)     // Calcula la relación del pivot
            { pivot= q.getElement(j,i)/q.getElement(i,i);
              for (k= n; k >=i; k--)
                  q.setElement(j, k, q.getElement(j,k)-
                  q.getElement(i,k)*pivot);
              // q(j,k) -= q(i,k)*pivot; Actualiza la fila j por debajo de la diagonal
            }
        }
    }
    
    private static void back_solve(Matrix q) {
        int j, k, n;
        double t; 				// t- temporal
        n= q.getNumRows();
        
        for (j=n-1; j >=0; j--) 		// Comienza en la última fila
        {
            t= 0.0;
            for (k= j+1; k < n; k++)    // t += q(j,k)* q(k,n)
                t += q.getElement(j,k)* q.getElement(k,n);
            q.setElement(j, n,
            (q.getElement(j, n) -t)/q.getElement(j,j));
            // q(j, n)= (q(j, n) -t)/q(j,j);
        }
    }
    
    public static void divide_selection(Matrix q, int pivotRow, int pivotCol){
        int n;
        n = q.getNumCols();
        double denom = q.getElement(pivotRow,pivotCol);
        
        for(int j=0; j<n; j++){
            double ratio = q.getElement(pivotRow,j)/denom;
            q.setElement(pivotRow, j, ratio);
            
        }
        
    }
    
    public static void pivot_selection(Matrix q, int pivotRow, int pivotCol){
        
        //divide_selection(q, pivotRow, pivotCol);       //Reduce la fila seleccionada
        
        for(int i=pivotRow+1; i<q.getNumRows(); i++){
            double pivot = -q.getElement(i,pivotCol)/q.getElement(pivotRow,pivotCol);
            for(int j=0; j<q.getNumCols(); j++){
                double num = q.getElement(i,j) + q.getElement(pivotRow,j)*pivot;
                q.setElement(i, j, num);
            }
        }
    }
    
    public static void backSolve_selection(Matrix q, int backSolveRow, int backSolveCol){
        
        //divide_selection(q, pivotRow, pivotCol);       //Reduce la fila seleccionada
        
        for(int i=backSolveRow-1; i>=0; i--){
            double pivot = -q.getElement(i,backSolveCol)/q.getElement(backSolveRow,backSolveCol);
            for(int j=0; j<q.getNumCols(); j++){
                double num = q.getElement(i,j) + q.getElement(backSolveRow,j)*pivot;
                q.setElement(i, j, num);
            }
        }
    }
}

class MatrixDisplay extends JPanel {
    
    private int rows;
    private int cols;
    
    private Matrix matrix;
    
    private JTextField[][] cell;
    private JPanel rowPanel[];
    
    private int currentRow;         //realiza seguimiento de la fila enfocada
    private int currentCol;
    
    public MatrixDisplay(int rows, int cols) {
        //añade una fila y las columnas para los títulos
        this.rows = rows+1;
        this.cols = cols+1;
        matrix = new Matrix(rows,cols);
        initComponents();
    }
    
    
    private void initComponents() {
        
        int numPanels =rows+1;
        
        setLayout(new java.awt.GridLayout(numPanels, 0));
        rowPanel = new JPanel[numPanels];
        for(int i=0; i<numPanels; i++){
            rowPanel[i] = new JPanel();
            rowPanel[i].setLayout(new FlowLayout(FlowLayout.LEFT));
            add(rowPanel[i]);
        }
        
        cell = new JTextField[rows][cols];
        
        //Define las etiquetas de la primera fila
        for(int i=0; i<rows; i++)
            for(int j=0; j <cols; j++){
                cell[i][j] = new JTextField();
                cell[i][j].addFocusListener(new java.awt.event.FocusAdapter() {
                    public void focusGained(java.awt.event.FocusEvent evt) {
                        cellFocusGained(evt);}
                });
                cell[i][j].setColumns(5);
                cell[i][j].setHorizontalAlignment(JTextField.CENTER);
                rowPanel[i].add(cell[i][j]);
                
                if(i==0 || j==0)
                    cell[i][j].setEditable(false);
                else
                    cell[i][j].setEditable(true);
                
                //Etiquetas de la fila 0
                if(i == 0 && j!=0){
                    cell[0][j].setText("x" + Integer.toString(j-1) );
                    if(j == cols-1)
                        cell[0][j].setText("b");
                }
                
                
                //Etiquetas de la columna 0
                if(i!=0 && j==0)
                    cell[i][j].setText(Integer.toString(i));
            }
    }
    
    public Matrix getMatrix() throws  NumberFormatException{
        
        for(int i=1; i<rows; i++)
            for(int j=1; j<cols; j++){
                double num;
                if((cell[i][j].getText()).equals(""))
                    num = 0;
                else{
                    try{
                        num = Double.parseDouble(cell[i][j].getText());
                    }
                    catch(NumberFormatException e){
                        throw new NumberFormatException();
                    }
                    
                }
                matrix.setElement(i-1,j-1,num);
            }
        return matrix;
    }
    
    public void setMatrix(Matrix m) {
        NumberFormat nf = NumberFormat.getInstance();
        nf.setMaximumFractionDigits(4);
        for(int i=0; i<m.getNumRows(); i++)
            for(int j=0; j<m.getNumCols(); j++){
                String num = nf.format(m.getElement(i,j));
                cell[i+1][j+1].setText(num);
            }
    }
    
    public int getCurrentRow(){
        if(currentRow !=0)
            return currentRow -1;
        else
            return 0;
    }
    
    public int getCurrentCol(){
        if(currentCol !=0)
            return currentCol -1;
        else
            return 0;
    } 
    
    public void cellFocusGained(java.awt.event.FocusEvent evt){
          for(int i =1; i<rows; i++)
            for(int j =1; j<cols; j++)
                if(cell[i][j].hasFocus()){
                    currentRow =i;
                    currentCol =j;
                    break;
                }    
    }
}

class Model{
    
    private Matrix savedMatrix;
    private Matrix currentMatrix;
    private Matrix demoMatrix;
    private Matrix previousMatrix;
    
    public Matrix getCurrentMatrix(){
        return currentMatrix;
    }
    
    public void setCurrentMatrix(Matrix m){        
        currentMatrix =m;
        
        int rows = currentMatrix.getNumRows();
        int cols = currentMatrix.getNumCols();
        previousMatrix = new Matrix(rows, cols);
        
        for(int i=0; i<rows; i++)
            for(int j=0; j<cols; j++)
                previousMatrix.setElement(i,j, currentMatrix.getElement(i,j));        
    }
    
    public void setSavedMatrix(Matrix m){
        int rows;
        int cols;
        rows = m.getNumRows();
        cols = m.getNumCols();
        savedMatrix = new Matrix(rows,cols);
        for(int i=0; i<rows; i++)
            for(int j=0; j<cols; j++)
                savedMatrix.setElement(i,j, m.getElement(i,j));        
    }
    
    public Matrix getSavedMatrix(){       
        return savedMatrix;        
    }   
    
    public Matrix getPreviousMatrix(){
        return previousMatrix;
    }
    
    public Matrix getDemoMatrix(){
        setupDemo();
        return demoMatrix;
    } 
    
    public void reset(int rows, int cols){     
        currentMatrix = new Matrix(rows, cols);
    }
    
    public Matrix solve() throws NumberFormatException{
        int rows = currentMatrix.getNumRows();
        int cols = currentMatrix.getNumCols();
        if(cols <=1)
            throw new NumberFormatException();
        else{
            Matrix solutionMatrix = new Matrix(rows,1);
            Gauss.gaussian(currentMatrix, solutionMatrix);
            currentMatrix = new Matrix(rows, cols);
            currentMatrix.setIdentity();
            for(int i=0;i<rows; i++)
                currentMatrix.setElement(i,cols-1, solutionMatrix.getElement(i,0));
        }
        return currentMatrix;
    }
    
    public void setupDemo(){
        demoMatrix = new Matrix(3,4);
        demoMatrix.setElement(0,0,3);
        demoMatrix.setElement(0,1,1);
        demoMatrix.setElement(0,2,-2);
        demoMatrix.setElement(0,3,5);
        demoMatrix.setElement(1,0,2);
        demoMatrix.setElement(1,1,4);
        demoMatrix.setElement(1,2,3);
        demoMatrix.setElement(1,3,35);
        demoMatrix.setElement(2,0,1);
        demoMatrix.setElement(2,1,-3);
        demoMatrix.setElement(2,2,0);
        demoMatrix.setElement(2,3,-5);
    }
    
    public void divide_selection(int i, int j) throws IllegalArgumentException {
        if(Math.abs(currentMatrix.getElement(i,j)) <= 0.0000001)
            throw new IllegalArgumentException();
        else
            Gauss.divide_selection(currentMatrix,i,j);       
    }
    
    public void pivot_selection(int i, int j) throws IllegalArgumentException {
        if(Math.abs(currentMatrix.getElement(i,j)) <= 0.0000001)
            throw new IllegalArgumentException();
        else
            Gauss.pivot_selection(currentMatrix,i,j);
    }
    
    public void backSolve_selection(int i, int j) throws IllegalArgumentException {
        if(Math.abs(currentMatrix.getElement(i,j)) <= 0.0000001)
            throw new IllegalArgumentException();
        else
            Gauss.backSolve_selection(currentMatrix,i,j);
    }
    //Comprueba si la selección es la única x sin ceros de la fila
    public boolean backSolve_check2(int currentRow, int currentCol){
        boolean flag = false;
        for(int j=0; j<currentMatrix.getNumCols()-1; j++)
            if(Math.abs(currentMatrix.getElement(currentRow,j)) >= 0.0000001 && j!= currentCol)
                //la selección no es la única x sin ceros de la fila
                flag = true;
        if(Math.abs(currentMatrix.getElement(currentRow, currentCol)) <= 0.0000001)
            //En caso de que la selección sea 0, no sabemos si la selección es conocida o no.
            //backSolve_selection(i,j) se encargará de ello. Devolverá un valor true.
            flag = false;        
        
        return flag;       
    }
    
    //Comprueba si la selección está en la matriz b
    public boolean backSolve_check1(int currentCol){        
        if (currentCol == (currentMatrix.getNumCols() -1))
            return true;
        else
            return false;
    }
    
    public void swap_rows(int row1, int row2) throws IllegalArgumentException{
        double tempValue;
        if(row1>= currentMatrix.getNumRows() || row2>= currentMatrix.getNumRows())
            throw new IllegalArgumentException();
        else{
            for(int j=0; j<currentMatrix.getNumCols(); j++){
                tempValue = currentMatrix.getElement(row1, j);
                currentMatrix.setElement(row1, j, currentMatrix.getElement(row2,j));
                currentMatrix.setElement(row2, j, tempValue);
            }
        }
    }
    
    public void row_operation(int row1, double mult1, int row2, double mult2) throws IllegalArgumentException{
        
        if(row1>= currentMatrix.getNumRows() || row2>= currentMatrix.getNumRows()
                || row1 < 0 || row2< 0)
            throw new IllegalArgumentException();
        else{
            for(int j=0; j< currentMatrix.getNumCols(); j++){
                double addValue = currentMatrix.getElement(row2,j)*mult2;
                double newValue = currentMatrix.getElement(row1,j) * mult1 + addValue;
                currentMatrix.setElement(row1,j, newValue);
            }
        }
        
    }
}

class Matrix {
    private double[][] data;	    // Referencia a la matriz
    // Constructor para la matriz
    public Matrix(int m, int n) {
        data = new double[m][n];
    }
    
    public Matrix() {		    // Constructor predeterminado
        data = new double[1][1];
    }
    
    // Método para definir la identidad de Matrix
    public void setIdentity() {
        int i,j;
        int nrows = data.length;
        int ncols = data[0].length;
        for(i=0; i<nrows; i++)
            for(j=0; j<ncols; j++)
                if(i == j)
                    data[i][j]= 1.0;
                else
                    data[i][j]= 0.0;
    }
    
    public int getNumRows() {  // Devuelve el número de filas de Matrix
        return data.length;
    }
    public int getNumCols() {  // Devuelve el número de columnas de Matrix
        return data[0].length; 
    }
        public double getElement(int i, int j) { //Obtiene el elemento i,j
            return data[i][j];
        }
        public void setElement(int i, int j, double val) {
            data[i][j] = val;
        }
        
        public Matrix addMatrices(Matrix b) {
            Matrix result = null;
            int nrows = data.length;
            int ncols = data[0].length;
            int i,j;
            if (nrows==b.data.length && ncols==b.data[0].length) {
                result = new Matrix(nrows, ncols);
                for(i=0; i<nrows; i++)
                    for(j=0; j<ncols; j++)
                        result.data[i][j]= data[i][j]+ b.data[i][j];
            }
            return result;
        }
        
        public Matrix multMatrices(Matrix b) {
            Matrix result = null;
            int nrows = data.length;
            int p = data[0].length;
            int i,j,k;
            if(p == b.data.length) {
                result = new Matrix(nrows, b.data[0].length);
                for(i=0; i<nrows; i++)
                    for(j=0; j<result.data[0].length; j++) {
                        double t = 0.0;
                        for(k=0; k<p; k++) {
                            t += data[i][k] * b.data[k][j];   }
                        result.data[i][j]= t;
                    }
            }
            return result;
        }
        
        public void print() {
            for(int i=0; i< data.length; i++) {
                for(int j=0; j< data[0].length; j++)
                    System.out.print(data[i][j] + " ");
                System.out.println();
            }
            System.out.println();
        }
}