Desenvolvimento variaveis de folga restrição <=

Author: JeanHFerreira

SPX

@@ -0,0 +1 @@
+Subproject commit 6924e0778d5c5d3e73a4eb437d33d78846ae41e4

build/built-jar.properties

@@ -1,4 +1,4 @@
-#Wed, 09 Dec 2015 10:04:05 -0200
+#Thu, 10 Dec 2015 00:44:10 -0200
 
 
-/home/gusmao/NetBeansProjects/SPX=
+C\:\\Users\\Jean_H_xD\\workspace\\LSR=

build/classes/Loader.class

@@ -3,4 +3,4 @@ do.depend=false
 do.jar=true
 javac.debug=true
 javadoc.preview=true
-user.properties.file=/home/gusmao/.netbeans/8.0.2/build.properties
+user.properties.file=C:\\Users\\Jean_H_xD\\AppData\\Roaming\\NetBeans\\8.0\\build.properties

build/classes/Matriz.class

@@ -1,5 +1,4 @@
 
-
 /**
  * Problema de Programação Linear
  *
@@ -10,11 +9,11 @@ public class PPL {
     private final double COEFICIENTE_INVALIDO = Double.MAX_VALUE;
     private final int NUMERO_MAXIMO_ITERACOES;
 
-    private final int MAIOR = 2;
-    private final int MAIOR_IGUAL = 1;
-    private final int IGUAL = 0;
-    private final int MENOR_IGUAL = -1;
-    private final int MENOR = -2;
+    public static final int MAIOR = 2;
+    public static final int MAIOR_IGUAL = 1;
+    public static final int IGUAL = 0;
+    public static final int MENOR_IGUAL = -1;
+    public static final int MENOR = -2;
 
     private boolean maximizacao;                //é um problema de maximização?
     private int qtdeRestricoes;                 //quantidade de restrições deste problema
@@ -41,7 +40,11 @@ public class PPL {
      * @param naoNegatividadeMaiorIgual
      * @param naoNegatividadeReais
      */
-    public PPL(boolean maximizacao, int qtdeRestricoes, int qtdeVariaveis, double[] funcaoObjetivo, double[][] restricoes, int[] sinalRestricoes, int[] naoNegatividadeMenorIgual, int[] naoNegatividadeMaiorIgual, int[] naoNegatividadeReais) {
+    public PPL(boolean maximizacao, int qtdeRestricoes,
+            int qtdeVariaveis, double[] funcaoObjetivo,
+            double[][] restricoes, int[] sinalRestricoes,
+            int[] naoNegatividadeMenorIgual, int[] naoNegatividadeMaiorIgual,
+            int[] naoNegatividadeReais) {
         this.maximizacao = maximizacao;
         this.qtdeRestricoes = qtdeRestricoes;
         this.qtdeVariaveis = qtdeVariaveis;
@@ -65,7 +68,8 @@ public PPL(boolean maximizacao, int qtdeRestricoes, int qtdeVariaveis, double[]
      * @param restricoes
      * @param naoNegatividade
      */
-    public PPL(String tipo, int qtdeRestricoes, int qtdeVariaveis, String funcaoObjetivo, String[] restricoes, String[] naoNegatividade) {
+    public PPL(String tipo, int qtdeRestricoes, int qtdeVariaveis, 
+            String funcaoObjetivo, String[] restricoes, String[] naoNegatividade) {
         if (tipo.equalsIgnoreCase("max")) {     //Se for Max, set True.. se não, continue false
             this.maximizacao = true;
         }
@@ -104,14 +108,14 @@ public void print() {
                     System.out.print("  " + restricoes[i][j] + "X" + (j + 1));
                 }
             }
-            switch (sinalRestricoes[i]) {
-                case -1:
+            switch (getSinalRestricoes()[i]) {
+                case PPL.MENOR_IGUAL:
                     System.out.print(" <= " + restricoes[i][j]);
                     break;
-                case 0:
+                case PPL.MAIOR_IGUAL:
                     System.out.print(" >= " + restricoes[i][j]);
                     break;
-                case 1:
+                case PPL.IGUAL:
                     System.out.print(" = " + restricoes[i][j]);
                     break;
             }
@@ -153,7 +157,7 @@ public void print() {
 
     private void insertRestricoes(String[] restricoes) {
         this.restricoes = new double[qtdeRestricoes][qtdeVariaveis + 1];
-        this.sinalRestricoes = new int[qtdeRestricoes];
+        this.setSinalRestricoes(new int[qtdeRestricoes]);
         String atual;
         String numero;
         char c;
@@ -185,13 +189,13 @@ private void insertRestricoes(String[] restricoes) {
                     } else if (numero.charAt(0) == '<' || numero.charAt(0) == '>' || numero.charAt(0) == '=') {
                         switch (numero.charAt(0)) {
                             case '<':                                   //<=
-                                this.sinalRestricoes[i] = this.MENOR_IGUAL;
+                                this.getSinalRestricoes()[i] = this.getMENOR_IGUAL();
                                 break;
                             case '>':
-                                this.sinalRestricoes[i] = this.MAIOR_IGUAL;           //>=
+                                this.getSinalRestricoes()[i] = this.getMAIOR_IGUAL();           //>=
                                 break;
                             case '=':
-                                this.sinalRestricoes[i] = this.IGUAL;            //=
+                                this.getSinalRestricoes()[i] = this.getIGUAL();            //=
                                 break;
                         }
                         numero = "";
@@ -310,42 +314,42 @@ public PPL gerarDual() {
         for (int i = 0; i < this.qtdeVariaveis; i++) {
             if (!isMaximizacao()) {                  //PRIMAL DE MAXIMIZACAO
                 if (this.naoNegatividadeMenorIgual[i] == 1) {
-                    sinalRestricoesDual[i] = this.MAIOR_IGUAL;
+                    sinalRestricoesDual[i] = this.getMAIOR_IGUAL();
                 }
                 if (this.naoNegatividadeMaiorIgual[i] == 1) {
-                    sinalRestricoesDual[i] = this.MENOR_IGUAL;
+                    sinalRestricoesDual[i] = this.getMENOR_IGUAL();
                 }
                 if (this.naoNegatividadeReais[i] == 1) {
-                    sinalRestricoesDual[i] = this.IGUAL;
+                    sinalRestricoesDual[i] = this.getIGUAL();
                 }
             } else {                                  //PRIMAL DE MINIMIZACAO
                 if (this.naoNegatividadeMenorIgual[i] == 1) {
-                    sinalRestricoesDual[i] = this.MENOR_IGUAL;
+                    sinalRestricoesDual[i] = this.getMENOR_IGUAL();
                 }
                 if (this.naoNegatividadeMaiorIgual[i] == 1) {
-                    sinalRestricoesDual[i] = this.MAIOR_IGUAL;
+                    sinalRestricoesDual[i] = this.getMAIOR_IGUAL();
                 }
                 if (this.naoNegatividadeReais[i] == 1) {
-                    sinalRestricoesDual[i] = this.IGUAL;
+                    sinalRestricoesDual[i] = this.getIGUAL();
                 }
             }
         }
         //add nao negatividade
         for (int i = 0; i < this.qtdeRestricoes; i++) {
             if (!isMaximizacao()) {                  //PRIMAL DE MAXIMIZACAO
-                switch (this.sinalRestricoes[i]) {
-                    case MENOR_IGUAL:
+                switch (this.getSinalRestricoes()[i]) {
+                    case PPL.MENOR_IGUAL:
                         naoNegatividadeMenorIgualDual[i] = 1;
                         break;
-                    case MAIOR_IGUAL:
+                    case PPL.MAIOR_IGUAL:
                         naoNegatividadeMaiorIgualDual[i] = 1;
                         break;
-                    case IGUAL:
+                    case PPL.IGUAL:
                         naoNegatividadeReaisDual[i] = 1;
                         break;
                 }
             } else {                                  //PRIMAL DE MINIMIZACAO
-                switch (this.sinalRestricoes[i]) {
+                switch (this.getSinalRestricoes()[i]) {
                     case MENOR_IGUAL:
                         naoNegatividadeMaiorIgualDual[i] = 1;
                         break;
@@ -383,11 +387,7 @@ public void setMaximizacao(boolean maximizacao) {
      * change the state of maximizacao
      */
     public void changeMaximizacao() {
-        if (isMaximizacao()) {
-            this.maximizacao = false;
-        } else {
-            this.maximizacao = true;
-        }
+        this.maximizacao = !isMaximizacao();
     }
 
     /**
@@ -495,4 +495,32 @@ public int getNUMERO_MAXIMO_ITERACOES() {
         return NUMERO_MAXIMO_ITERACOES;
     }
 
+    public int[] getSinalRestricoes() {
+        return sinalRestricoes;
+    }
+
+    public void setSinalRestricoes(int[] sinalRestricoes) {
+        this.sinalRestricoes = sinalRestricoes;
+    }
+
+    public int getMAIOR() {
+        return MAIOR;
+    }
+
+    public int getMAIOR_IGUAL() {
+        return MAIOR_IGUAL;
+    }
+
+    public int getIGUAL() {
+        return IGUAL;
+    }
+
+    public int getMENOR_IGUAL() {
+        return MENOR_IGUAL;
+    }
+
+    public int getMENOR() {
+        return MENOR;
+    }
+
 }

build/classes/PPL.class

@@ -13,17 +13,77 @@ public class SimplexSolver {
 
     public SimplexSolver(PPL problema) {
         this.problema = problema;
-        if (problema.getQtdeRestricoes() > problema.getQtdeVariaveis() * FATOR_TOLERANCIA) {
-            this.problema = problema.gerarDual();
-        }
+        /*if (problema.getQtdeRestricoes() > problema.getQtdeVariaveis() * FATOR_TOLERANCIA) {
+         this.problema = problema.gerarDual();
+         }*/
 
     }
 
-    private void insertVariaveisArtificiais() {
+    public void insertVariaveisArtificiais() {
         //Se houver restrição <= , precisa de M
         //Verificando se há restrições do tipo <=
         for (int i = 0; i < this.problema.getQtdeRestricoes(); i++) {
-            
+            //Garantia que o lado direito é positivo
+            if (this.problema.getRestricoes()[i][this.problema.getQtdeVariaveis()] < 0.0) {
+                for (int j = 0; j <= this.problema.getQtdeVariaveis(); j++) {
+                    this.problema.getRestricoes()[i][j] *= -1; // Troca osinal das restrições
+                }
+                this.problema.getSinalRestricoes()[i] *= -1; //Troca a direção do sinal
+            }
+            switch (this.problema.getSinalRestricoes()[i]) {
+                case PPL.MAIOR_IGUAL:
+                    break;
+                case PPL.MENOR_IGUAL:
+                    int novaQtdRestricoes = problema.getQtdeRestricoes();
+                    int novaQtdVariaveis = problema.getQtdeVariaveis() + 1;
+                    double[][] novasRestricoes = new double[novaQtdRestricoes][novaQtdVariaveis + 1];
+                    for (int k = 0; k < novaQtdRestricoes; k++) {
+                        for (int l = 0; l < novaQtdVariaveis - 1; l++) {
+                            //Mantém as restrições
+                            //System.out.println("["+k+"] ["+l+"] "+problema.getRestricoes()[k][l]);
+                            novasRestricoes[k][l] = problema.getRestricoes()[k][l];
+                        }
+                        //Seta o valor da variável de folga
+                        novasRestricoes[i][novaQtdVariaveis-1]=1;
+                        //Move o lado direito para a direita
+                        novasRestricoes[k][novaQtdVariaveis] = problema.getRestricoes()[k][problema.getQtdeVariaveis()];
+                    }
+                    problema.getSinalRestricoes()[i] = PPL.IGUAL;
+                    //Copia a função objetivo + nova variável de foga com coeficiente 0
+                    double[] novaFuncaoObjetivo = new double[novaQtdVariaveis];
+                    for (int k = 0; k < novaQtdVariaveis - 1; k++) {
+                        novaFuncaoObjetivo[k] = problema.getFuncaoObjetivo()[k];
+                    }
+                    novaFuncaoObjetivo[novaQtdVariaveis - 1] = 0;
+                    //Copia a restrição de não negatividade
+                    int[] novaNaoNegatividadeMenorIgual = new int[novaQtdVariaveis];
+                    for (int k = 0; k < novaQtdVariaveis - 1; k++) {
+                        novaNaoNegatividadeMenorIgual[k] = problema.getNaoNegatividadeMenor()[k];
+                    }
+                    novaNaoNegatividadeMenorIgual[novaQtdVariaveis - 1] = 0;
+
+                    int[] novaNaoNegatividadeMaiorIgual = new int[novaQtdVariaveis];
+                    for (int k = 0; k < novaQtdVariaveis - 1; k++) {
+                        novaNaoNegatividadeMaiorIgual[k] = problema.getNaoNegatividadeMaior()[k];
+                    }
+                    novaNaoNegatividadeMaiorIgual[novaQtdVariaveis - 1] = 1;
+
+                    int[] novaNaoNegatividadeReais = new int[novaQtdVariaveis];
+                    for (int k = 0; k < novaQtdVariaveis - 1; k++) {
+                        novaNaoNegatividadeReais[k] = problema.getNaoNegatividadeIgual()[k];
+                    }
+                    novaNaoNegatividadeReais[novaQtdVariaveis - 1] = 0;
+                    problema.setRestricoes(novasRestricoes);
+                    problema.setFuncaoObjetivo(novaFuncaoObjetivo);
+                    problema.setNaoNegatividadeMaior(novaNaoNegatividadeMaiorIgual);
+                    problema.setNaoNegatividadeIgual(novaNaoNegatividadeReais);
+                    problema.setNaoNegatividadeMenor(novaNaoNegatividadeMenorIgual);
+                    problema.setQtdeRestricoes(novaQtdRestricoes);
+                    problema.setQtdeVariaveis(novaQtdVariaveis);
+                    break;
+                case PPL.IGUAL:
+                    break;
+            }
         }
     }
 

build/classes/SimplexSolver.class

@@ -74,7 +74,8 @@ public static void main(String[] args) {
         instancia = new PPL(tipo, qtdeRestricoes, qtdeVariaveis, funcaoObjetivo, restricoes, naoNegatividade);
         SimplexSolver simplexSolver = new SimplexSolver(instancia);
         simplexSolver.getProblema().print();
-        
+        simplexSolver.insertVariaveisArtificiais();
+        simplexSolver.getProblema().print();
 //        System.out.println("\nRealizando DUAL\n");
 //        instancia = instancia.gerarDual();
 //        instancia.print();