Inserindo variaveis artificiais e primeira etapa do simplex revisado 2

Author: gusmaoFelipe

build/built-jar.properties

@@ -1,4 +1,4 @@
-#Thu, 10 Dec 2015 00:44:10 -0200
+#Thu, 10 Dec 2015 18:01:45 -0200
 
 
-C\:\\Users\\Jean_H_xD\\workspace\\LSR=
+/home/gusmao/NetBeansProjects/SPX=

build/classes/Loader.class

@@ -4,7 +4,7 @@
  */
 public class SimplexNormal {
 
-    double[][] Matriz = {{-696, -399, 100, 0, 0, 0, -900},
+    double[][] matriz = {{-696, -399, 100, 0, 0, 0, -900},
                           {1,    2,    0,  1, 0, 0,   4},
                           {3,    1,    0,  0, 1, 0,   3},
                           {4,    3,   -1,  0, 0, 1,   6}};
@@ -17,8 +17,8 @@ private int entraBase() {
         double menorValor = 0;
         int posicao = 0;
         for (int i = 0; i < (colunas-1); i++) {
-            if (Matriz[0][i] < menorValor) {
-                menorValor = Matriz[0][i];
+            if (matriz[0][i] < menorValor) {
+                menorValor = matriz[0][i];
                 posicao = i;
             }
 
@@ -34,8 +34,8 @@ private int saiBase(int entraBase) {
         double valorMenor = -1, valor = 0;
         int posicao = -1;
         for (int i = 1; i < linhas; i++) {
-            if (Matriz[i][entraBase] > 0 && Matriz[i][colunas - 1] > 0) {
-                valor = Matriz[i][colunas - 1] / Matriz[i][entraBase];
+            if (matriz[i][entraBase] > 0 && matriz[i][colunas - 1] > 0) {
+                valor = matriz[i][colunas - 1] / matriz[i][entraBase];
                 if (valorMenor == -1 || valor < valorMenor) {
                     valorMenor = valor;
                     posicao = i;
@@ -47,21 +47,21 @@ private int saiBase(int entraBase) {
 
     private void calcularMatriz(int entraBase, int saiBase) {
 
-        double pivo = Matriz[saiBase][entraBase];
+        double pivo = matriz[saiBase][entraBase];
 
         // dividir linha da Matriz do pivo pelo pivo
         if (pivo != 1) {
             for (int i = 0; i < colunas; i++) {
-                Matriz[saiBase][i] = Matriz[saiBase][i] / pivo;
+                matriz[saiBase][i] = matriz[saiBase][i] / pivo;
             }
         }
 
         // Aplicar Gauss-Jordan
         for (int i = 0; i < linhas; i++) {
-          double   valor = Matriz[i][entraBase] * (-1);
+          double   valor = matriz[i][entraBase] * (-1);
             for (int j = 0; j < colunas; j++) {
                 if (saiBase != i) {
-                    Matriz[i][j] = Matriz[i][j] + (Matriz[saiBase][j] * valor);
+                    matriz[i][j] = matriz[i][j] + (matriz[saiBase][j] * valor);
                 }
             }    
         }
@@ -71,7 +71,7 @@ private void calcularMatriz(int entraBase, int saiBase) {
     public void printarMatriz() {
         for (int i = 0; i < linhas; i++) {
             for (int j = 0; j < colunas; j++) {
-                System.out.printf("%.2f ",Matriz[i][j]);
+                System.out.printf("%.2f ",matriz[i][j]);
             }
             System.out.println("");
         }

build/classes/Matriz.class

@@ -8,28 +8,34 @@
 public class SimplexRevisado {
 
     private final double FATOR_TOLERANCIA = 1.2;        //20% maior
-    public static int nIteracoes;
     private int qtdeVarArificiais;
+    private int qtdeIteracoes;
 
     private PPL problema;                   //instancia de um problema de programação linear
     private PPL simplex;                    //tabelaSimplex
     private int[] base;                   //variáveis da base
     private Matrix matriz;
     private double[] funcaoObjetivo;        //funcaoObjetivo atual
     private double[] colunaPivot;           //coluna do pivot
+    private double[] ladoDireito;           //lado direito do simplex
 
     public SimplexRevisado(PPL problema) {
-        qtdeVarArificiais = 0;
+        this.qtdeVarArificiais = 0;
+        this.qtdeIteracoes = 0;
         this.problema = problema;
-        nIteracoes = 0;
         if (problema.getQtdeRestricoes() > problema.getQtdeVariaveis() * FATOR_TOLERANCIA) {
-            //this.problema = problema.gerarDual();
+            this.problema = problema.gerarDual();
         }
         this.simplex = this.problema;
         //Etapa 01: construção da solução inicial viável
         this.insertVariaveisArtificiais();
         this.insereElementosDaMatriz();
         this.insereBase();
+        this.insereCoeficientesDaFuncaoObjetivo();
+        //Etapa 02: calcular a matriz inversa na iteração i
+        for (int i = 0; i < simplex.getNUMERO_MAXIMO_ITERACOES(); i++) {
+
+        }
     }
 
     //Etapa 01: construção da solução inicial viável
@@ -72,19 +78,56 @@ private void insereElementosDaMatriz() {
 
     private void insereBase() {
         //guardando os índices das variáveis da base inicial
-        for (int i = 0; i < simplex.getQtdeVariaveis() - qtdeVarArificiais; i++) {
+        int qtdeBase = simplex.getQtdeVariaveis() - qtdeVarArificiais;
+        base = new int[qtdeBase];
+        for (int i = 0; i < qtdeBase; i++) {
             base[i] = qtdeVarArificiais + i - 1;
         }
     }
 
     private void insereCoeficientesDaFuncaoObjetivo() {
+        //guardando os valores dos coeficientes da funcao objetivo inicial
+        funcaoObjetivo = new double[simplex.getQtdeVariaveis()];
         for (int i = 0; i < simplex.getQtdeVariaveis(); i++) {
-            
+            funcaoObjetivo[i] = simplex.getFuncaoObjetivo()[i];
+        }
+    }
+
+    private void insereLadoDireiro() {
+        //guardando os valores do lado direito iniciais
+        ladoDireito = new double[base.length];
+        for (int i = 0; i < base.length; i++) {
+            ladoDireito[i] = simplex.getQtdeVariaveis();
         }
     }
 
-    //Etapa 02: calcular a inversa de B utilizando decomposição
+    //Etapa 02: calcular a inversa na iteracao i
     private void calculaInversa() {
+        //encontra valor mais negativo
+        boolean hasNegativo = false;
+        double menor = 0.0;
+        int maisNegativo = -1;
+        for (int i = 0; i < simplex.getQtdeVariaveis(); i++) {
+            if (funcaoObjetivo[i] < 0.0) {
+                hasNegativo = true;
+                menor = funcaoObjetivo[i];
+                maisNegativo = i;
+            }
+        }
+        if (!hasNegativo) {     //se não houver valores negativos, chegou a solução ótima
+            printSucesso();
+        } else {
+            //terminar
+        }
+    }
+
+    private void printSucesso() {
+        System.out.println("=================================================================");
+        System.out.println("Solução viável encontrada após " + qtdeIteracoes + " iterações.\n");
+        int variaveisDoProblema = simplex.getQtdeVariaveis() - qtdeVarArificiais;
+        for (int i = 0; i < variaveisDoProblema; i++) {
+            System.out.print("X" + i + ": " + ladoDireito[i] + "\n");
+        }
     }
 
     private void insertFolga(double coeficiente, int i) {