package proy3;
/**
 * Clase que que resuelve sistemas de ecuaciones de nxn, en caso de ser 2x2 se realiza optimizadamente
 */
public class SistemaEcuaciones
{
    /**
     * matriz de doubles que representa el sistema de ecuaciones
     */
    private double[][] q;
    /**
     * arreglo en el que se almacenan las respuestas del sistema
     */
    private double[] soluciones;

    /**
     * Constructor del sistema de ecuaciones
     *
     * @param a
     *            matriz Izquierda que conforma la matriz representacion
     *            (coeficientes de las incognitas)
     * @param b
     *            arreglo con los datos necesarios para la solucion del sistema
     *            (parte derecha de la matrz representacion
     * @param nIncognitas
     *            numero de incognitas del sistema
     */
    public SistemaEcuaciones(double[][] a, double b[], int nIncognitas)
    {
        soluciones = new double[nIncognitas];
        if (nIncognitas < 3)
            solucionarCramer(a, b, nIncognitas);
        else
            solucionarGauss(a, b, nIncognitas);
    }

    /**
     * metodo Cramer para solucionar sistemas de ecuaciones resolucion de
     * Sistemas de ecuaciones con 2 incognitas se usa para la resolucion de las
     * homogeneas por ser mas eficiente No requiere la manipulacion de las
     * matrices <b>pre: </b> a, b inicializados de la forma
     * a[nIncognitas][nIncognitas] y b[nIncognitas], nIncognitas = 2 <b>post:
     * </b> se ha agregado al arreglo soluciones las soluciones del sistema
     *
     * @param a
     *            matriz Izquierda que conforma la matriz representacion
     *            (coeficientes de las incognitas)
     * @param b
     *            arreglo con los datos necesarios para la solucion del sistema
     *            (parte derecha de la matrz representacion
     * @param nIncognitas
     *            numero de incognitas del sistema
     */
    public void solucionarCramer(double[][] a, double b[], int nIncognitas)
    {
        if (nIncognitas == 2)
        {
            double A = (b[0] * a[1][1] - b[1] * a[0][1]) / (a[0][0] * a[1][1] - a[1][0] * a[0][1]);
            double B = (a[0][0] * b[1] - a[1][0] * b[0]) / (a[0][0] * a[1][1] - a[1][0] * a[0][1]);
            soluciones[0] = A;
            soluciones[1] = B;
        }
        else
        {
            System.out.println("error no pueden existir menos de 2 ingonitas pues nos dan ecuaciones cuadraticas");
        }
    }

    /**
     * Metodo encargado de juntar la matriz de la izquierda con el arreglo para
     * formar la matriz representacion <b>pre: </b> a, b inicializados de la
     * forma a[nIncognitas][nIncognitas] y b[nIncognitas], nIncognitas > 2
     * <b>post: </b> se han insertado los datos de la matriz y el arreglo en la
     * matriz q, la ultima columna contiene los valores del arreglo b
     *
     * @param a
     *            matriz Izquierda que conforma la matriz representacion
     *            (coeficientes de las incognitas)
     * @param b
     *            arreglo con los datos necesarios para la solucion del sistema
     *            (parte derecha de la matrz representacion
     * @param nIncognitas
     *            numero de incognitas del sistema
     */
    public void cargar(double[][] a, double b[], int nIncognitas)
    {
        q = new double[nIncognitas][nIncognitas + 1];
        for (int i = 0; i < nIncognitas; i++)
        {
            for (int j = 0; j < nIncognitas; j++)
            {
                q[i][j] = a[i][j];
            }
            q[i][nIncognitas] = b[i];
        }
    }

    /**
     * Metodo proveniente de la documentacion mencionada Diagonaliza la matriz,
     * es decir, vuelve 0 todo lo que esta debajo de la diagonal En la
     * documentacion lo llaman forward_solve <b>pre: </b> matriz q cargada
     * <b>post: </b> valores bajo la diagonal de q quedan en 0
     */
    public void triangularizar()
    {
        int i, j, k, maxr, n;
        double t, pivot;
        n = q.length;
        for (i = 0; i < n; i++)
        {
            maxr = i;
            for (j = i + 1; j < n; j++)
                if (Math.abs(q[j][i]) > Math.abs(q[j][i]))
                    maxr = j;
            if (maxr != i)
                for (k = i; k <= n; k++)
                {
                    t = q[i][k];
                    q[i][k] = q[maxr][k];
                    q[maxr][k] = t;
                }
            for (j = i + 1; j < n; j++)
            {
                pivot = q[j][i] / q[i][i];
                for (k = n; k >= i; k--)
                    q[j][k] = q[j][k] - q[i][k] * pivot;
            }
        }
    }

    /**
     * Metodo proveniente de la documentacion mencionada Se apoya en la
     * reduccion de gauss para resolver el sistema de ecuaciones Usa un metodo
     * que en la documentacion llaman back_solve y lo que hace es hallar
     * variables de "abajo  para arriba" <b>pre: </b> a, b inicializados de la
     * forma a[nIncognitas][nIncognitas] y b[nIncognitas], nIncognitas > 2
     * <b>post: </b> en el arreglo soluciones se encuentran las soluciones del
     * sistema
     *
     * @param a
     *            matriz Izquierda que conforma la matriz representacion
     *            (coeficientes de las incognitas)
     * @param b
     *            arreglo con los datos necesarios para la solucion del sistema
     *            (parte derecha de la matrz representacion
     * @param nIncognitas
     *            numero de incognitas del sistema
     */
    public void solucionarGauss(double[][] a, double[] b, int nIncognitas)
    {
        cargar(a, b, nIncognitas);
        triangularizar();
        int j, k, n;
        double t;
        n = nIncognitas;
        for (j = n - 1; j >= 0; j--)
        {
            t = 0.0;
            for (k = j + 1; k < n; k++)
                t += q[j][k] * q[k][n];
            q[j][n] = (q[j][n] - t) / q[j][j];
        }
        for (int i = 0; i < n; i++)
            soluciones[i] = q[i][n];
    }

    /**
     * retorna un arreglo con las soluciones del sistema
     *
     * @return arreglo con las soluciones del sistema
     */
    public double[] darSoluciones()
    {
        return soluciones;
    }
}