optional objectives now considered in MILP

src/MILP.js

@@ -5,6 +5,7 @@
 /*global console*/
 /*global process*/
 var Solution = require("./Solution.js");
+var Tableau = require("./Tableau/Tableau.js");
 
 //-------------------------------------------------------------------
 //-------------------------------------------------------------------
@@ -42,45 +43,46 @@ function sortByEvaluation(a, b) {
 //-------------------------------------------------------------------
 // Applying cuts on a tableau and resolving
 //-------------------------------------------------------------------
-function applyCuts(tableau, cuts){
+Tableau.prototype.applyCuts = function (branchingCuts){
     // Restoring initial solution
-    tableau.restore();
-
-    tableau.addCutConstraints(cuts);
-    tableau.solve();
+    this.restore();
 
+    this.addCutConstraints(branchingCuts);
+    this.simplex();
     // Adding MIR cuts
     var fractionalVolumeImproved = true;
     while(fractionalVolumeImproved){
-        var fractionalVolumeBefore = tableau.computeFractionalVolume(true);
-
-        tableau.applyMIRCuts();
-        tableau.solve();
+        var fractionalVolumeBefore = this.computeFractionalVolume(true);
+        this.applyMIRCuts();
+        this.simplex();
 
-        var fractionalVolumeAfter = tableau.computeFractionalVolume(true);
+        var fractionalVolumeAfter = this.computeFractionalVolume(true);
 
         // If the new fractional volume is bigger than 90% of the previous one
         // we assume there is no improvement from the MIR cuts
         if(fractionalVolumeAfter >= 0.9 * fractionalVolumeBefore){
             fractionalVolumeImproved = false;
         }
     }
-}
+};
 
 //-------------------------------------------------------------------
 // Function: MILP
 // Detail: Main function, my attempt at a mixed integer linear programming
 //         solver
 //-------------------------------------------------------------------
-function MILP(model) {
+Tableau.prototype.MILP = function () {
     var branches = [];
     var iterations = 0;
-    var tableau = model.tableau;
 
     // This is the default result
     // If nothing is both *integral* and *feasible*
     var bestEvaluation = Infinity;
     var bestBranch = null;
+    var bestOptionalObjectivesEvaluations = [];
+    for (var oInit = 0; oInit < this.optionalObjectives.length; oInit += 1){
+        bestOptionalObjectivesEvaluations.push(Infinity);
+    }
 
     // And here...we...go!
 
@@ -92,7 +94,7 @@ function MILP(model) {
     while (branches.length > 0) {
         // Get a model from the queue
         branch = branches.pop();
-        if (branch.relaxedEvaluation >= bestEvaluation) {
+        if (branch.relaxedEvaluation > bestEvaluation) {
             continue;
         }
 
@@ -101,37 +103,53 @@ function MILP(model) {
 
         // Adding cut constraints
         var cuts = branch.cuts;
-
-        applyCuts(tableau, cuts);
-
-        // console.log(iterations, tableau.matrix[0][tableau.rhsColumn], tableau.feasible, branches.length);
+        this.applyCuts(cuts);
 
         iterations++;
-        if (tableau.feasible === false) {
+        if (this.feasible === false) {
             continue;
         }
 
-        var evaluation = tableau.evaluation;
-        if (evaluation >= bestEvaluation) {
+        var evaluation = this.evaluation;
+        if (evaluation > bestEvaluation) {
             // This branch does not contain the optimal solution
             continue;
         }
 
+        // To deal with the optional objectives
+        if (evaluation === bestEvaluation){
+            var isCurrentEvaluationWorse = true;
+            for (var o = 0; o < this.optionalObjectives.length; o += 1){
+                if (this.optionalObjectives[o].reducedCosts[0] > bestOptionalObjectivesEvaluations[o]){
+                    break;
+                } else if (this.optionalObjectives[o].reducedCosts[0] < bestOptionalObjectivesEvaluations[o]) {
+                    isCurrentEvaluationWorse = false;
+                    break;
+                }
+            }
+
+            if (isCurrentEvaluationWorse){
+                continue;
+            }
+        }
+
         // Is the model both integral and feasible?
-        if (tableau.isIntegral() === true) {
+        if (this.isIntegral() === true) {
             if (iterations === 1) {
-                tableau.updateVariableValues();
-                return new MilpSolution(tableau.getSolution(), iterations);
+                // tableau.updateVariableValues();
+                return new MilpSolution(this.getSolution(), iterations);
             }
-
             // Store the solution as the bestSolution
             bestBranch = branch;
             bestEvaluation = evaluation;
+            for (var oCopy = 0; oCopy < this.optionalObjectives.length; oCopy += 1){
+                bestOptionalObjectivesEvaluations[oCopy] = this.optionalObjectives[oCopy].reducedCosts[0];
+            }
         } else {
             if (iterations === 1) {
                 // Saving the first iteration
                 // TODO: implement a better strategy for saving the tableau?
-                tableau.save();
+                this.save();
             }
 
             // If the solution is
@@ -171,7 +189,7 @@ function MILP(model) {
             // the model is not integral at this point, and fails.
 
             // Find out where we want to split the solution
-            var variable = tableau.getMostFractionalVar();
+            var variable = this.getMostFractionalVar();
             // var variable = tableau.getFractionalVarWithLowestCost();
             var varIndex = variable.index;
 
@@ -215,12 +233,10 @@ function MILP(model) {
     // Adding cut constraints for the optimal solution
     if (bestBranch !== null) {
         // The model is feasible
-        applyCuts(tableau, bestBranch.cuts);
-        tableau.updateVariableValues();
+        this.applyCuts(bestBranch.cuts);
+        // tableau.updateVariableValues();
     }
 
     // Solving a last time
-    return new MilpSolution(tableau.getSolution(), iterations);
-}
-
-module.exports = MILP;
+    return new MilpSolution(this.getSolution(), iterations);
+};

src/Model.js

@@ -345,17 +345,14 @@ Model.prototype.solve = function () {
         this.tableauInitialized = true;
     }
 
-    if (this.getNumberOfIntegerVariables() > 0) {
-        return MILP(this);
-    } else {
-        var solution = this.tableau.solve().getSolution();
-        this.tableau.updateVariableValues();
-        return solution;
-    }
-};
-
-Model.prototype.compileSolution = function () {
-    return this.tableau.compileSolution();
+    return this.tableau.solve();
+    // if (this.getNumberOfIntegerVariables() > 0) {
+    //     return MILP(this);
+    // } else {
+    //     var solution = this.tableau.solve().getSolution();
+    //     this.tableau.updateVariableValues();
+    //     return solution;
+    // }
 };
 
 Model.prototype.isFeasible = function () {

src/Tableau/Tableau.js

@@ -58,6 +58,16 @@ function Tableau(precision) {
 }
 module.exports = Tableau;
 
+Tableau.prototype.solve = function () {
+    if (this.model.getNumberOfIntegerVariables() > 0) {
+        this.MILP();
+    } else {
+        this.simplex();
+    }
+    this.updateVariableValues();
+    return this.getSolution();
+};
+
 function OptionalObjective(priority, nColumns) {
     this.priority = priority;
     this.reducedCosts = new Array(nColumns);
@@ -66,6 +76,12 @@ function OptionalObjective(priority, nColumns) {
     }
 }
 
+OptionalObjective.prototype.copy = function () {
+    var copy = new OptionalObjective(this.priority, this.reducedCosts.length);
+    copy.reducedCosts = this.reducedCosts.slice();
+    return copy;
+};
+
 Tableau.prototype.setOptionalObjective = function (priority, column, cost) {
     var objectiveForPriority = this.objectivesByPriority[priority];
     if (objectiveForPriority === undefined) {

src/Tableau/backup.js

@@ -26,6 +26,12 @@ Tableau.prototype.copy = function () {
 
     copy.availableIndexes = this.availableIndexes.slice();
 
+    var optionalObjectivesCopy = [];
+    for(var o = 0; o < this.optionalObjectives.length; o++){
+        optionalObjectivesCopy[o] = this.optionalObjectives[o].copy();
+    }
+    copy.optionalObjectives = optionalObjectivesCopy;
+
 
     var matrix = this.matrix;
     var matrixCopy = new Array(this.height);
@@ -97,5 +103,14 @@ Tableau.prototype.restore = function () {
         this.colByVarIndex[v] = savedCols[v];
     }
 
-    this.availableIndexes = save.availableIndexes.slice();
+
+    if (save.optionalObjectives.length > 0 && this.optionalObjectives.length > 0) {
+        this.optionalObjectives = [];
+        this.optionalObjectivePerPriority = {};
+        for(var o = 0; o < save.optionalObjectives.length; o++){
+            var optionalObjectiveCopy = save.optionalObjectives[o].copy();
+            this.optionalObjectives[o] = optionalObjectiveCopy;
+            this.optionalObjectivePerPriority[optionalObjectiveCopy.priority] = optionalObjectiveCopy;
+        }
+    }
 };

src/Tableau/simplex.js

@@ -11,7 +11,7 @@ var Tableau = require("./Tableau.js");
 // Function: solve
 // Detail: Main function, linear programming solver
 //-------------------------------------------------------------------
-Tableau.prototype.solve = function () {
+Tableau.prototype.simplex = function () {
     // Bounded until proven otherwise
     this.bounded = true;
 
@@ -159,6 +159,9 @@ Tableau.prototype.phase2 = function () {
             while (enteringColumn === 0 && optionalCostsColumns.length > 0 && o < nOptionalObjectives) {
                 var optionalCostsColumns2 = [];
                 var reducedCosts = this.optionalObjectives[o].reducedCosts;
+
+                enteringValue = this.precision;
+
                 for (var i = 0; i <= optionalCostsColumns.length; i++) {
                     c = optionalCostsColumns[i];
                     reducedCost = reducedCosts[c];
@@ -199,6 +202,8 @@ Tableau.prototype.phase2 = function () {
         var leavingRow = 0;
         var minQuotient = Infinity;
 
+        var varIndexByRow = this.varIndexByRow;
+
         for (var r = 1; r <= lastRow; r++) {
             var row = matrix[r];
             var rhsValue = row[rhsColumn];

src/expressions.js

@@ -130,7 +130,7 @@ Constraint.prototype.setVariableCoefficient = function (newCoefficient, variable
 
 Constraint.prototype.relax = function (weight, priority) {
     this.relaxation = createRelaxationVariable(this.model, weight, priority);
-    this._relax(this.relaxation, priority);
+    this._relax(this.relaxation);
 };
 
 Constraint.prototype._relax = function (error) {