linny-r 1.3.2 → 1.3.4

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
@@ -932,6 +932,23 @@ function commandLineSettings() {
       gurobi_path = path_list[i];
       max_v = parseInt(match[1]);
     }
+    match = path_list[i].match(/[\/\\]cplex[\/\\]bin/i);
+    if(match) {
+      cplex_path = path_list[i];
+    } else {
+      // NOTE: CPLEX may create its own environment variable for its paths
+      match = path_list[i].match(/%(.*cplex.*)%/i);
+      if(match) {
+        const cpl = process.env[match[1]].split(path.delimiter);
+        for(let i = 0; i < cpl.length; i++) {
+          match = cpl[i].match(/[\/\\]cplex[\/\\]bin/i);
+          if(match) {
+            cplex_path = cpl[i];
+            break;
+          }
+        }
+      }
+    }
     match = path_list[i].match(/[\/\\]scip[^\/\\]+[\/\\]bin/i);
     if(match) scip_path = path_list[i];
     match = path_list[i].match(/inkscape/i);
@@ -964,8 +981,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 +1016,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.4",
   "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++) {
@@ -1466,6 +1467,23 @@ function commandLineSettings() {
       gurobi_path = path_list[i];
       max_v = parseInt(match[1]);
     }
+    match = path_list[i].match(/[\/\\]cplex[\/\\]bin/i);
+    if(match) {
+      cplex_path = path_list[i];
+    } else {
+      // NOTE: CPLEX may create its own environment variable for its paths
+      match = path_list[i].match(/%(.*cplex.*)%/i);
+      if(match) {
+        const cpl = process.env[match[1]].split(path.delimiter);
+        for(let i = 0; i < cpl.length; i++) {
+          match = cpl[i].match(/[\/\\]cplex[\/\\]bin/i);
+          if(match) {
+            cplex_path = cpl[i];
+            break;
+          }
+        }
+      }
+    }
     match = path_list[i].match(/[\/\\]scip[^\/\\]+[\/\\]bin/i);
     if(match) scip_path = path_list[i];
     match = path_list[i].match(/inkscape/i);
@@ -1498,8 +1516,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 +1630,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-gui.js

@@ -5273,9 +5273,30 @@ class GUIController extends Controller {
     md.element('actor').value = mapping.actor || '';
     md.element('prefix').value = mapping.prefix || '';
     const
-        ft = Object.keys(mapping.from_to).sort(ciCompare),
+        tc = (mapping.top_clusters ?
+            Object.keys(mapping.top_clusters).sort(ciCompare) : []),
+        ft = (mapping.from_to ?
+            Object.keys(mapping.from_to).sort(ciCompare) : []),
         sl = [];
+    if(tc.length) {
+      sl.push('<div style="font-weight: bold; margin:4px 2px 2px 2px">',
+        'Names for top-level clusters:</div>');
+      // Add text inputs for selected cluster nodes
+      for(let i = 0; i < tc.length; i++) {
+        const
+            ti = mapping.top_clusters[tc[i]],
+            state = (ti === tc[i] ? 'color: #e09000; ' :
+                this.validName(ti) ? 'color: #0000c0; ' :
+                'font-style: italic; color: red; ');
+        sl.push('<div class="paste-option"><span>', tc[i], '</span> ',
+            '<div class="paste-select"><input id="paste-selc-', i,
+            '" type="text" style="', state, 'font-size: 12px" value="',
+            ti, '"></div></div>');
+      }
+    }
     if(ft.length) {
+      sl.push('<div style="font-weight: bold; margin:4px 2px 2px 2px">',
+        'Mapping of nodes to link from/to:</div>');
       // Add selectors for unresolved FROM/TO nodes
       for(let i = 0; i < ft.length; i++) {
         const ti = mapping.from_to[ft[i]];
@@ -5286,8 +5307,8 @@ class GUIController extends Controller {
               '</option></select></div></div>');
         }
       }
-      md.element('scroll-area').innerHTML = sl.join('');
     }
+    md.element('scroll-area').innerHTML = sl.join('');
     // Open dialog, which will call pasteSelection(...) on OK
     this.paste_modal.show();
   }
@@ -5297,10 +5318,18 @@ class GUIController extends Controller {
     // proceeds to paste
     const
         md = this.paste_modal,
-        mapping = Object.assign(md.mapping, {});
+        mapping = Object.assign(md.mapping, {}),
+        tc = (mapping.top_clusters ?
+            Object.keys(mapping.top_clusters).sort(ciCompare) : []),
+        ft = (mapping.from_to ?
+            Object.keys(mapping.from_to).sort(ciCompare) : []);
     mapping.actor = md.element('actor').value;
     mapping.prefix = md.element('prefix').value.trim();
     mapping.increment = true;
+    for(let i = 0; i < tc.length; i++) {
+      const cn = md.element('selc-' + i).value.trim();
+      if(this.validName(cn)) mapping.top_clusters[tc[i]] = cn;
+    }
     this.pasteSelection(mapping);
   }
   
@@ -5325,6 +5354,7 @@ console.log('HERE xml', xml);
         entities_node = childNodeByTag(xml, 'entities'),
         from_tos_node = childNodeByTag(xml, 'from-tos'),
         extras_node = childNodeByTag(xml, 'extras'),
+        selc_node = childNodeByTag(xml, 'selected-clusters'),
         selection_node = childNodeByTag(xml, 'selection'),
         actor_names = [],
         new_entities = [],
@@ -5335,7 +5365,7 @@ console.log('HERE xml', xml);
     
     function fullName(node) {
       // Returns full entity name inferred from XML node data
-      if(node.nodeName === 'from-to') {
+      if(node.nodeName === 'from-to' || node.nodeName === 'selc') {
         const
             n = xmlDecoded(nodeParameterValue(node, 'name')),
             an = xmlDecoded(nodeParameterValue(node, 'actor-name'));
@@ -5525,6 +5555,17 @@ console.log('HERE xml', xml);
     if(parseInt(mts) === MODEL.time_created.getTime() &&
         ca === fca && mapping.from_prefix === mapping.to_prefix &&
         !(mapping.prefix || mapping.actor || mapping.increment)) {
+      // Prompt for names of selected cluster nodes
+      if(selc_node.childNodes.length && !mapping.prefix) {
+        mapping.top_clusters = {};
+        for(let i = 0; i < selc_node.childNodes.length; i++) {
+          const
+              c = selc_node.childNodes[i],
+              fn = fullName(c),
+              mn = mappedName(fn);
+          mapping.top_clusters[fn] = mn;
+        }
+      }
       this.promptForMapping(mapping);
       return;
     }
@@ -6525,11 +6566,12 @@ class GUIMonitor {
           })
         .then((data) => {
             try {
-              const jsr = JSON.parse(data);
-              if(jsr.solver !== VM.solver_name) {
-                UI.notify(`Solver on ${jsr.server} is ${jsr.solver}`);              
-              }
+              const
+                  jsr = JSON.parse(data),
+                  svr = `Solver on ${jsr.server} is ${jsr.solver}`;
+              if(jsr.solver !== VM.solver_name) UI.notify(svr);              
               VM.solver_name = jsr.solver;
+              document.getElementById('host-logo').title  = svr;
             } catch(err) {
               console.log(err, data);
               UI.alert('ERROR: Unexpected data from server: ' +

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-model.js

@@ -1609,16 +1609,20 @@ class LinnyRModel {
         extras = [],
         from_tos = [],
         xml = [],
-        ft_xml = [],
         extra_xml = [],
+        ft_xml = [],
+        selc_xml = [],
         selected_xml = [];
     for(let i = 0; i < this.selection.length; i++) {
       const obj = this.selection[i];
       entities[obj.type].push(obj);
-      selected_xml.push('<sel>' + xmlEncoded(obj.displayName) + '</sel>');
+      if(obj instanceof Cluster) selc_xml.push(
+          '<selc name="', xmlEncoded(obj.name),
+          '" actor-name="', xmlEncoded(obj.actor.name), '"></selc>');
+      selected_xml.push(`<sel>${xmlEncoded(obj.displayName)}</sel>`);
     }
-    // Expand clusters by adding all its model entities to their respective
-    // lists
+    // Expand (sub)clusters by adding all their model entities to their
+    // respective lists
     for(let i = 0; i < entities.Cluster.length; i++) {
       const c = entities.Cluster[i];
       c.clearAllProcesses();
@@ -1714,7 +1718,8 @@ class LinnyRModel {
         '"><entities>', xml.join(''),
         '</entities><from-tos>', ft_xml.join(''),
         '</from-tos><extras>', extra_xml.join(''),
-        '</extras><selection>', selected_xml.join(''),
+        '</extras><selected-clusters>', selc_xml.join(''),
+        '</selected-clusters><selection>', selected_xml.join(''),
         '</selection></copy>'].join('');
   }
   
@@ -3236,6 +3241,7 @@ class LinnyRModel {
       for(let i = 0; i < constraints.length; i++) {
         const
             c = constraints[i],
+            // NOTE: constraints in list have levels greater than near-zero
             fl = c.from_node.actualLevel(t),
             tl = c.to_node.actualLevel(t);
         let tcp;
@@ -3306,10 +3312,10 @@ class LinnyRModel {
                 if(af > VM.NEAR_ZERO) {
                   // Prevent division by zero
                   // NOTE: level can be zero even if actual flow > 0!
-                  const al = p.actualLevel(dt);
+                  const al = p.nonZeroLevel(dt);
                   // NOTE: scale to level only when level > 1, or fixed
                   // costs for start-up or first commit will be amplified 
-                  if(al > VM.ON_OFF_THRESHOLD) cp -= pr * af / Math.max(al, 1);
+                  if(al > VM.NEAR_ZERO) cp -= pr * af / Math.max(al, 1);
                 }
               }
             }
@@ -3428,8 +3434,8 @@ class LinnyRModel {
         p.cost_price[t] = cp;
         // For stocks, the CP includes stock price on t-1
         if(p.is_buffer) {
-          const prevl = p.actualLevel(t-1);
-          if(prevl > 0) {
+          const prevl = p.nonZeroLevel(t-1);
+          if(prevl > VM.NEAR_ZERO) {
             cp = (cnp +  prevl * p.stockPrice(t-1)) / (qnp + prevl);
           }
           p.stock_price[t] = cp;
@@ -3486,7 +3492,7 @@ class LinnyRModel {
         // Then (also) look for links having AF = 0 ...
         for(let i = links.length-1; i >= 0; i--) {
           const af = links[i].actualFlow(t);
-          if(Math.abs(af) < VM.SIG_DIF_FROM_ZERO) {
+          if(Math.abs(af) < VM.NEAR_ZERO) {
             // ... and set their UCP to 0
             links[i].unit_cost_price = 0;
             links.splice(i, 1);
@@ -3522,7 +3528,7 @@ class LinnyRModel {
       let hcp = VM.MINUS_INFINITY;
       for(let i = 0; i < p.inputs.length; i++) {
         const l = p.inputs[i];
-        if(l.from_node instanceof Process && l.actualFlow(t) > 0) {
+        if(l.from_node instanceof Process && l.actualFlow(t) > VM.NEAR_ZERO) {
           const ld = l.actualDelay(t);
           // NOTE: only consider the allocated share of cost
           let cp = l.from_node.costPrice(t - ld) * l.share_of_cost;

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   
@@ -3256,19 +3255,22 @@ class VirtualMachine {
         if(ubx.isStatic) {
           // If UB is very high (typically: undefined, so +INF), try to infer
           // a lower value for UB to use for the ON/OFF binary
-          let ub = ubx.result(0);
+          let ub = ubx.result(0),
+              hub = ub;
           if(ub > VM.MEGA_UPPER_BOUND) {
-            ub = p.highestUpperBound([]);
+            hub = p.highestUpperBound([]);
             // If UB still very high, warn modeler on infoline and in monitor
-            if(ub > VM.MEGA_UPPER_BOUND) {
-              const msg = 'High upper bound (' + this.sig4Dig(ub) +
+            if(hub > VM.MEGA_UPPER_BOUND) {
+              const msg = 'High upper bound (' + this.sig4Dig(hub) +
                   ') for <strong>' + p.displayName + '</strong>' +
                   ' will compromise computation of its binary variables';
               UI.warn(msg);
               this.logMessage(this.block_count,
                   'WARNING: ' + msg.replace(/<\/?strong>/g, '"'));
             }
-          } else {
+          }
+          if(hub !== ub) {
+            ub = hub;
             this.logMessage(this.block_count,
                 `Inferred upper bound for ${p.displayName}: ${this.sig4Dig(ub)}`);
           }
@@ -3772,7 +3774,7 @@ class VirtualMachine {
           for(let k = 0; k < l; k++) {
             const
                 vi = svl[k],
-                slack = x[vi + j],
+                slack = parseFloat(x[vi + j]),
                 absl = Math.abs(slack);
             if(absl > VM.NEAR_ZERO) {
               const v = this.variables[vi - 1];
@@ -4731,8 +4733,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 +6446,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 +6465,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 +6475,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 +6517,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 = {};