linny-r 1.3.2 → 1.3.3

package/console.js

@@ -87,7 +87,7 @@ console.log('Module directory:', MODULE_DIRECTORY);
 console.log('Working directory:', WORKING_DIRECTORY);
 
 // Currently, these external solvers are supported:
-const SUPPORTED_SOLVERS = ['gurobi', 'scip', 'lp_solve'];
+const SUPPORTED_SOLVERS = ['gurobi', 'cplex', 'scip', 'lp_solve'];
 
 const
     // Load the MILP solver (dependent on Node.js: `fs`, `os` and `path`)
@@ -126,7 +126,7 @@ Possible options are:
                         [name]-stats.txt in (workspace)/reports
   run                   will run the loaded model
   solver=[name]         will select solver [name], or warn if not found
-                        (name choices: Gurobi, SCIP or LP_solve)
+                        (name choices: Gurobi, CPLEX, SCIP or LP_solve)
   user=[identifier]     user ID will be used to log onto remote servers
   verbose               will output solver messages to the console
   workspace=[path]      will create workspace in [path] instead of (main)/user
@@ -964,8 +964,25 @@ function commandLineSettings() {
           'WARNING: Failed to access the Gurobi command line application');
     }
   }
+  // Check if cplex(.exe) exists in its directory
+  let sp = path.join(cplex_path, 'cplex' + (PLATFORM.startsWith('win') ? '.exe' : ''));
+  const need_cplex = !settings.solver || settings.preferred_solver === 'cplex';
+  try {
+    fs.accessSync(sp, fs.constants.X_OK);
+    console.log('Path to CPLEX:', sp);
+    if(need_cplex) {
+      settings.solver = 'cplex';
+      settings.solver_path = sp;
+    }
+  } catch(err) {
+    // Only report error if CPLEX is needed
+    if(need_cplex) {
+      console.log(err.message);
+      console.log('WARNING: CPLEX application not found in', sp);
+    }
+  }
   // Check if scip(.exe) exists in its directory
-  let sp = path.join(scip_path, 'scip' + (PLATFORM.startsWith('win') ? '.exe' : ''));
+  sp = path.join(scip_path, 'scip' + (PLATFORM.startsWith('win') ? '.exe' : ''));
   const need_scip = !settings.solver || settings.preferred_solver === 'scip';
   try {
     fs.accessSync(sp, fs.constants.X_OK);
@@ -982,10 +999,9 @@ function commandLineSettings() {
     }
   }
   // Check if lp_solve(.exe) exists in main directory
-  const
-      sp = path.join(WORKING_DIRECTORY,
-          'lp_solve' + (PLATFORM.startsWith('win') ? '.exe' : '')),
-      need_lps = !settings.solver || settings.preferred_solver === 'lp_solve';
+  sp = path.join(WORKING_DIRECTORY,
+      'lp_solve' + (PLATFORM.startsWith('win') ? '.exe' : ''));
+  const need_lps = !settings.solver || settings.preferred_solver === 'lp_solve';
   try {
     fs.accessSync(sp, fs.constants.X_OK);
     console.log('Path to LP_solve:', sp);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linny-r",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Executable graphical language with WYSIWYG editor for MILP models",
   "main": "server.js",
   "scripts": {

package/server.js

@@ -123,7 +123,7 @@ function checkNodeModule(name) {
 }
 
 // Currently, these external solvers are supported:
-const SUPPORTED_SOLVERS = ['gurobi', 'scip', 'lp_solve'];
+const SUPPORTED_SOLVERS = ['gurobi', 'cplex', 'scip', 'lp_solve'];
 
 // Load class MILPSolver
 const MILPSolver = require('./static/scripts/linny-r-milp.js');
@@ -1458,6 +1458,7 @@ function commandLineSettings() {
   const path_list = process.env.PATH.split(path.delimiter);
   let gurobi_path = '',
       scip_path = '',
+      cplex_path = '',
       match,
       max_v = -1;
   for(let i = 0; i < path_list.length; i++) {
@@ -1468,6 +1469,8 @@ function commandLineSettings() {
     }
     match = path_list[i].match(/[\/\\]scip[^\/\\]+[\/\\]bin/i);
     if(match) scip_path = path_list[i];
+    match = path_list[i].match(/[\/\\]cplex[\/\\]bin/i);
+    if(match) cplex_path = path_list[i];
     match = path_list[i].match(/inkscape/i);
     if(match) settings.inkscape = path_list[i];
   }
@@ -1498,8 +1501,25 @@ function commandLineSettings() {
           'WARNING: Failed to access the Gurobi command line application');
     }
   }
+  // Check if cplex(.exe) exists in its directory
+  let sp = path.join(cplex_path, 'cplex' + (PLATFORM.startsWith('win') ? '.exe' : ''));
+  const need_cplex = !settings.solver || settings.preferred_solver === 'cplex';
+  try {
+    fs.accessSync(sp, fs.constants.X_OK);
+    console.log('Path to CPLEX:', sp);
+    if(need_cplex) {
+      settings.solver = 'cplex';
+      settings.solver_path = sp;
+    }
+  } catch(err) {
+    // Only report error if CPLEX is needed
+    if(need_cplex) {
+      console.log(err.message);
+      console.log('WARNING: CPLEX application not found in', sp);
+    }
+  }
   // Check if scip(.exe) exists in its directory
-  let sp = path.join(scip_path, 'scip' + (PLATFORM.startsWith('win') ? '.exe' : ''));
+  sp = path.join(scip_path, 'scip' + (PLATFORM.startsWith('win') ? '.exe' : ''));
   const need_scip = !settings.solver || settings.preferred_solver === 'scip';
   try {
     fs.accessSync(sp, fs.constants.X_OK);
@@ -1595,7 +1615,7 @@ function createWorkspace() {
       data: path.join(SETTINGS.user_dir, 'data'),
       diagrams: path.join(SETTINGS.user_dir, 'diagrams'),
       modules: path.join(SETTINGS.user_dir, 'modules'),
-      solver_output: path.join(SETTINGS.user_dir, 'solver'),
+      solver_output: path.join(SETTINGS.user_dir, 'solver')
     };
   // Create these sub-directories if not aready there
   try {

package/static/scripts/linny-r-milp.js

@@ -82,6 +82,27 @@ module.exports = class MILPSolver {
        14: 'Optimization still in progress',
        15: 'User-specified objective limit has been reached'
       };
+    } else if(this.id === 'cplex') {
+      this.ext = '.lp';
+      this.user_model = path.join(workspace.solver_output, 'usr_model.lp');
+      this.solver_model = path.join(workspace.solver_output, 'solver_model.lp');
+      this.solution = path.join(workspace.solver_output, 'model.sol');
+      // NOTE: CPLEX log file is located in the Linny-R working directory
+      this.log = path.join(workspace.solver_output, 'cplex.log');
+      // NOTE: CPLEX command line accepts space separated commands ...
+      this.args = [
+          'read ' + this.user_model,
+          'write ' + this.solver_model + ' lp',
+          'set timelimit 300',
+          'optimize',
+          'write ' + this.solution + ' 0',
+          'quit'
+        ];
+      // ... when CPLEX is called with -c option; then each command must be
+      // enclosed in double quotes; SCIP outputs its messages to a log file
+      // terminal, so these must be caputured in a log file
+      this.solve_cmd = 'cplex -c "' + this.args.join('" "') + '"';
+      this.errors = {};
     } else if(this.id === 'scip') {
       this.ext = '.lp';
       this.user_model = path.join(workspace.solver_output, 'usr_model.lp');
@@ -217,6 +238,18 @@ module.exports = class MILPSolver {
           this.args[0] = 'TimeLimit=' + timeout;
           const options = {windowsHide: true};
           spawn = child_process.spawnSync(this.solver_path, this.args, options);
+        } else if(this.id === 'cplex') {          
+          // Delete previous solver model file (if any)
+          try {
+            if(this.solver_model) fs.unlinkSync(this.solver_model);
+          } catch(err) {
+            // Ignore error
+          }
+          // Spawn using the LP_solve approach
+          const
+              cmd = this.solve_cmd.replace(/timelimit \d+/, `timelimit ${timeout}`),
+              options = {shell: true, cwd: 'user/solver', stdio: 'ignore', windowsHide: true};
+          spawn = child_process.spawnSync(cmd, options);
         } else if(this.id === 'scip') {          
           // When using SCIP, take the LP_solve approach
           const
@@ -311,6 +344,64 @@ module.exports = class MILPSolver {
           result.error = 'No solution found';
         }
       }
+    } else if(this.id === 'cplex') {
+      result.seconds = 0;
+      const
+          msg = fs.readFileSync(this.log, 'utf8'),
+          no_license = (msg.indexOf('No license found') >= 0);
+      // `messages` must be an array of strings
+      result.messages = msg.split(os.EOL);
+      let solved = false,
+          output = [];
+      if(no_license) {
+        result.error = 'Too many variables for unlicensed CPLEX solver';
+        result.status = -13;
+      } else if(result.status !== 0) {
+        // Non-zero solver exit code indicates serious trouble
+        result.error = 'CPLEX solver terminated with error';
+        result.status = -13;
+      } else {
+        try {
+          output = fs.readFileSync(this.solution, 'utf8').trim();
+          if(output.indexOf('CPLEXSolution') >= 0) {
+            solved = true;
+            output = output.split(os.EOL);
+          }
+        } catch(err) {
+          console.log('No CPLEX solution file');
+        }
+      }
+      if(solved) {
+        // CPLEX saves solution as XML, but for now just extract the
+        // status and then the variables
+        let i = 0;
+        while(i < output.length) {
+          const s = output[i].split('"');
+          if(s[0].indexOf('objectiveValue') >= 0) {
+            result.obj = s[1];
+          } else if(s[0].indexOf('solutionStatusValue') >= 0) {
+            result.status = s[1];
+          } else if(s[0].indexOf('solutionStatusString') >= 0) {
+            result.error = s[1];
+            break;
+          }
+          i++;
+        }
+        if(['1', '101', '102'].indexOf(result.status) >= 0) {
+          result.status = 0;
+          result.error = '';
+        }
+        // Fill dictionary with variable name: value entries 
+        while(i < output.length) {
+          const m = output[i].match(/^.*name="(X[^"]+)".*value="([^"]+)"/);
+          if(m !== null)  x_dict[m[1]] = m[2];
+          i++;
+        }
+        // Fill the solution vector, adding 0 for missing columns
+        getValuesFromDict();
+      } else {
+        console.log('No solution found');
+      }
     } else if(this.id === 'scip') {
       result.seconds = 0;
       // `messages` must be an array of strings
@@ -332,19 +423,21 @@ module.exports = class MILPSolver {
           const m = result.messages[i];
           if(m.startsWith('SCIP Status')) {
             if(m.indexOf('problem is solved') >= 0) {
-              solved = true;
+              if(m.indexOf('infeasible') >= 0) {
+                result.status = (m.indexOf('unbounded') >= 0 ? 14 : 12);
+              } else if(m.indexOf('unbounded') >= 0) {
+                result.status = 13;
+              } else {
+                solved = true;
+              }
             } else if(m.indexOf('interrupted') >= 0) {
               if(m.indexOf('time limit') >= 0) {
                 result.status = 5;
               } else if(m.indexOf('memory limit') >= 0) {
                 result.status = 6;
-              } else if(m.indexOf('infeasible') >= 0) {
-                result.status = (m.indexOf('unbounded') >= 0 ? 14 : 12);
-              } else if(m.indexOf('unbounded') >= 0) {
-                result.status = 13;
               }
-              result.error = this.errors[result.status];
             }
+            if(result.status) result.error = this.errors[result.status];
           } else if (m.startsWith('Solving Time')) {
             result.seconds = parseFloat(m.split(':')[1]);
           }

package/static/scripts/linny-r-vm.js

@@ -2249,7 +2249,7 @@ class VirtualMachine {
     }
     // NOTES:
     // (1) Processes have NO slack variables, because sufficient slack is
-    //     provided by addinng slack variables to products; these slack
+    //     provided by adding slack variables to products; these slack
     //     variables will have high cost penalty values in the objective
     //     function, to serve as "last resort" to still obtain a solution when
     //     the "real" product levels are overconstrained
@@ -2352,7 +2352,7 @@ class VirtualMachine {
         }
       }
       // Likewise get the upper bound
-      if(p.equal_bounds) {
+      if(p.equal_bounds && p.lower_bound.defined) {
         u = l;
       } else if(p.upper_bound.defined) {
         if(p.upper_bound.isStatic) {
@@ -2575,9 +2575,9 @@ class VirtualMachine {
       // efficient, while cash flows are inferred properties and will not
       // result in an "unbounded problem" error message from the solver
       this.code.push(
-          [VMI_set_const_bounds, [a.cash_in_var_index,
+          [VMI_set_bounds, [a.cash_in_var_index,
               VM.MINUS_INFINITY, VM.PLUS_INFINITY, true]],
-          [VMI_set_const_bounds, [a.cash_out_var_index,
+          [VMI_set_bounds, [a.cash_out_var_index,
               VM.MINUS_INFINITY, VM.PLUS_INFINITY, true]]
       );
     }
@@ -2590,18 +2590,17 @@ class VirtualMachine {
       if(!MODEL.ignored_entities[k]) {
         p = MODEL.processes[k];
         lbx = p.lower_bound;
-        ubx = (p.equal_bounds ? lbx : p.upper_bound);
+        // NOTE: if UB = LB, set UB to LB only if LB is defined,
+        // because LB expressions default to -INF while UB expressions
+        // default to + INF
+        ubx = (p.equal_bounds && lbx.defined ? lbx : p.upper_bound);
+        if(lbx.isStatic) lbx = lbx.result(0);
+        if(ubx.isStatic) ubx = ubx.result(0);
         // NOTE: pass TRUE as fourth parameter to indicate that +INF
         // and -INF can be coded as the infinity values used by the
         // solver, rather than the Linny-R values used to detect
         // unbounded problems
-        if(lbx.isStatic && ubx.isStatic) {
-          this.code.push([VMI_set_const_bounds,
-              [p.level_var_index, lbx.result(0), ubx.result(0), true]]);
-        } else {
-          this.code.push([VMI_set_var_bounds,
-              [p.level_var_index, lbx, ubx, true]]);
-        }
+        this.code.push([VMI_set_bounds, [p.level_var_index, lbx, ubx, true]]);
         // Add level variable index to "fixed" list for specified rounds
         const rf = p.actor.round_flags;
         if(rf != 0) {
@@ -2629,17 +2628,17 @@ class VirtualMachine {
           // If no slack, the bound constraints can be set on the
           // variables themselves
           lbx = p.lower_bound;
-          ubx = (p.equal_bounds ? lbx : p.upper_bound);
-          if(lbx.isStatic && ubx.isStatic) {
-            this.code.push([VMI_set_const_bounds,
-                [vi, lbx.result(0), ubx.result(0)]]);
-          } else {
-            this.code.push([VMI_set_var_bounds, [vi, lbx, ubx]]);
-          }
+          // NOTE: if UB = LB, set UB to LB only if LB is defined,
+          // because LB expressions default to -INF while UB expressions
+          // default to + INF
+          ubx = (p.equal_bounds && lbx.defined ? lbx : p.upper_bound);
+          if(lbx.isStatic) lbx = lbx.result(0);
+          if(ubx.isStatic) ubx = ubx.result(0);
+          this.code.push([VMI_set_bounds, [vi, lbx, ubx]]);
         } else {
           // Otherwise, set bounds of stock variable to -INF and +INF,
           // as product constraints will be added later on
-          this.code.push([VMI_set_const_bounds,
+          this.code.push([VMI_set_bounds,
               [vi, VM.MINUS_INFINITY, VM.PLUS_INFINITY]]);
         }
       }
@@ -3224,7 +3223,7 @@ class VirtualMachine {
         // To deal with this, the default equations will NOT be set when UB <= 0,
         // while the "exceptional" equations (q.v.) will NOT be set when UB > 0.
         // This can be realized using a special VM instruction:
-        ubx = (p.equal_bounds && p.lower_bound.text ? p.lower_bound : p.upper_bound);
+        ubx = (p.equal_bounds && p.lower_bound.defined ? p.lower_bound : p.upper_bound);
         this.code.push([VMI_set_add_constraints_flag, [ubx, '>', 0]]);
 
         // NOTE: if UB <= 0 the following constraints will be prepared but NOT added   
@@ -4731,8 +4730,6 @@ class VirtualMachine {
       return [-2, 2, 6];
     } else if(this.solver_name === 'gurobi') {
       return [1, 3, 4, 6, 11, 12, 14];
-    } else if(this.solver_name === 'scip') {
-      return [];
     } else {
       return [];
     }
@@ -6446,8 +6443,8 @@ from) the k'th coefficient.
 
 */
 
-function VMI_set_const_bounds(args) {
-  // `args`: [var_index, number, number]
+function VMI_set_bounds(args) {
+  // `args`: [var_index, number or expression, number or expression]
   const
       vi = args[0],
       vbl = VM.variables[vi - 1][1],
@@ -6465,7 +6462,8 @@ function VMI_set_const_bounds(args) {
     // if this is the first round
     if(VM.current_round) {
       l = vbl.actualLevel(VM.t);
-      //PATCH!!
+      // QUICK PATCH! should resolve that small non-zero process levels
+      // computed in prior round make problem infeasible 
       if(l < 0.0005) l = 0;
     } else {
       l = 0;
@@ -6474,17 +6472,22 @@ function VMI_set_const_bounds(args) {
     fixed = ' (FIXED ' + vbl.displayName + ')';
   } else {
     // Set bounds as specified by the two arguments
-    l = (args[1] === VM.UNDEFINED ? 0 : args[1]),
-    u = Math.min(args[2], inf_val);
+    l = args[1];
+    if(l instanceof Expression) l = l.result(VM.t);
+    if(l === VM.UNDEFINED) l = 0;
+    u = args[2];
+    if(u instanceof Expression) u = u.result(VM.t);
+    u = Math.min(u, VM.PLUS_INFINITY);
     if(solver_inf) {
       if(l === VM.MINUS_INFINITY) l = -inf_val;
       if(u === VM.PLUS_INFINITY) u = inf_val;
     }
     fixed = '';
   }
-  // NOTE: to check, add this to the condition below: fixed !== ''
+  // NOTE: to see in the console whether fixing across rounds works, insert
+  // "fixed !== '' || " before DEBUGGING below
   if(DEBUGGING) {
-    console.log(['set_const_bounds [', k, '] ', vbl.displayName, ' t = ', VM.t,
+    console.log(['set_bounds [', k, '] ', vbl.displayName, ' t = ', VM.t,
       ' LB = ', VM.sig4Dig(l), ', UB = ', VM.sig4Dig(u), fixed].join(''));
   }
   // NOTE: since the VM vectors for lower bounds and upper bounds are
@@ -6511,61 +6514,6 @@ function VMI_set_const_bounds(args) {
   }
 }
 
-function VMI_set_var_bounds(args) {
-  // `args`: [var_index, expression, expression]
-  const
-      vi = args[0],
-      vbl = VM.variables[vi - 1][1],
-      k = VM.offset + vi,
-      r = VM.round_letters.indexOf(VM.round_sequence[VM.current_round]),
-      // Optional fourth parameter indicates whether the solver's
-      // infinity values should be used
-      solver_inf = args.length > 3 && args[3],
-      inf_val = (solver_inf ? VM.SOLVER_PLUS_INFINITY : VM.PLUS_INFINITY);
-  let l,
-      u,
-      fixed = (vi in VM.fixed_var_indices[r - 1]);
-  if(fixed) {
-    // Set both bounds equal to the level set in the previous round, or to 0
-    // if this is the first round
-    if(VM.current_round) {
-      l = vbl.actualLevel(VM.t);
-    } else {
-      l = 0;
-    }
-    u = l;
-    fixed = ' (FIXED ' + vbl.displayName + ')';
-  } else {
-    l = args[1].result(VM.t);
-    if(l === VM.UNDEFINED) l = 0;
-    u = Math.min(args[2].result(VM.t), inf_val);
-    if(solver_inf) {
-      if(l === VM.MINUS_INFINITY) l = -inf_val;
-      if(u === VM.PLUS_INFINITY) u = inf_val;
-    }
-    fixed = '';
-  }
-  // Here, too, no need to set default values
-  if(Math.abs(l) > VM.NEAR_ZERO || u !== inf_val) {
-    VM.lower_bounds[k] = l; 
-    VM.upper_bounds[k] = u;
-    // Check for peak increase -- see comments in VMI_set_const_bound
-    if(vbl.peak_inc_var_index >= 0) {
-      u = Math.max(0, u - vbl.b_peak[VM.block_count - 1]);
-      const
-          cvi = VM.chunk_offset + vbl.peak_inc_var_index,
-          piub = VM.upper_bounds[cvi];
-      if(piub) u = Math.max(piub, u);
-      VM.upper_bounds[cvi] = u;
-      VM.upper_bounds[cvi + 1] = u;
-    }
-  }
-  if(DEBUGGING) {
-    console.log(['set_var_bounds [', k, '] ', vbl.displayName, ' t = ', VM.t,
-      ' LB = ', l, ', UB = ', u, fixed].join(''));
-  }
-}
-
 function VMI_clear_coefficients(empty) {
   if(DEBUGGING) console.log('clear_coefficients');
   VM.coefficients = {};