linny-r 1.7.4 → 1.8.1

package/static/scripts/linny-r-gui-documentation-manager.js

@@ -283,7 +283,7 @@ class DocumentationManager {
     if(list.indexOf(this.entity) >= 0) {
       this.stopEditing();
       this.entity = null;
-      this.title.innerHTML = 'Documentation';
+      this.title.innerHTML = 'Information and documentation';
       this.viewer.innerHTML = this.about_linny_r;
     }
   }

package/static/scripts/linny-r-gui-expression-editor.js

@@ -74,16 +74,16 @@ Attributes, however, are case sensitive!">[Actor X|CF]</code> for cash flow.
   <code title="Number of last round in the sequence (1=a, 2=b, etc.)">lr</code>,
   <code title="Number of rounds in the sequence">nr</code>,
   <code title="Number of current experiment run (starts at 0)">x</code>,
-  <code title="Number of runs in the experiment">nx</code>,
-  <span title="Index variables of iterator dimensions)">
+  <code title="Number of runs in the current experiment">nx</code>,
+  <span title="Index variables of iterator dimensions">
     <code>i</code>, <code>j</code>, <code>k</code>,
   </span>
-  <code title="Number of time steps in 1 year)">yr</code>,
-  <code title="Number of time steps in 1 week)">wk</code>,
-  <code title="Number of time steps in 1 day)">d</code>,
-  <code title="Number of time steps in 1 hour)">h</code>,
-  <code title="Number of time steps in 1 minute)">m</code>,
-  <code title="Number of time steps in 1 second)">s</code>,
+  <code title="Number of time steps in 1 year">yr</code>,
+  <code title="Number of time steps in 1 week">wk</code>,
+  <code title="Number of time steps in 1 day">d</code>,
+  <code title="Number of time steps in 1 hour">h</code>,
+  <code title="Number of time steps in 1 minute">m</code>,
+  <code title="Number of time steps in 1 second">s</code>,
   <code title="A random number from the uniform distribution U(0, 1)">random</code>),
   constants (<code title="Mathematical constant &pi; = ${Math.PI}">pi</code>,
   <code title="Logical constant true = 1
@@ -178,8 +178,8 @@ NOTE: Grouping groups results in a single group, e.g., (1;2);(3;4;5) evaluates a
   }
 
   editExpression(event) {
-    // Infer which entity property expression is to edited from the button
-    // that was clicked, and then opens the dialog.
+    // Infer which entity property expression is to be edited from the
+    // button that was clicked, and then opens the dialog.
     const
         btn = event.target,
         ids = btn.id.split('-'), // 3-tuple [entity type, attribute, 'x']

package/static/scripts/linny-r-gui-paper.js

@@ -300,9 +300,9 @@ class Paper {
       at_process_ub_arrow: '#f0b0e8',
       // NOTE: special color when level at negative lower bound
       at_process_neg_lb: '#800050',
-      // Process with unbound level = +INF is displayed in maroon-red
-      infinite_level: '#a00001',
-      infinite_level_fill: '#ff90a0',
+      // Process with unbound level: +INF marine-blue, -INF maroon-red
+      plus_infinite_level: '#1000a0',
+      minus_infinite_level: '#a00010',
       // Process state change symbols are displayed in red
       switch_on_off: '#b00000',
       // Compound arrows with non-zero actual flow are displayed in red-purple
@@ -1979,9 +1979,16 @@ class Paper {
     if(MODEL.solved && !ignored) {
       if(l === VM.PLUS_INFINITY) {
         // Infinite level => unbounded solution
-        stroke_color = this.palette.infinite_level;
-        fill_color = this.palette.infinite_level_fill;
-        lrect_color = this.palette.infinite_level;
+        stroke_color = this.palette.plus_infinite_level;
+        fill_color = this.palette.above_upper_bound;
+        lrect_color = this.palette.plus_infinite_level;
+        font_color = 'white';
+        stroke_width = 2;
+      } else if(l === VM.MINUS_INFINITY) {
+        // Infinite level => unbounded solution
+        stroke_color = this.palette.minus_infinite_level;
+        fill_color = this.palette.below_lower_bound;
+        lrect_color = this.palette.minus_infinite_level;
         font_color = 'white';
         stroke_width = 2;
       } else if(l > ub - VM.SIG_DIF_FROM_ZERO ||

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

@@ -612,15 +612,21 @@ module.exports = class MILPSolver {
               json = fs.readFileSync(s.solution, 'utf8').trim(),
               sol = JSON.parse(json);
           result.seconds = sol.SolutionInfo.Runtime;
+          let status = sol.SolutionInfo.Status;
           // NOTE: Status = 2 indicates success!
-          if(sol.SolutionInfo.Status !== 2) {
-            result.status = sol.SolutionInfo.Status;
-            result.error = s.errors[result.status];
+          if(status !== 2) {
+            let msg = s.statusMessage(status);  
+            if(msg) {
+              // If solver exited with known status code, report message.
+              result.status = status;
+              result.solution = s.usableSolution(status);
+              result.error = msg;
+            }
             if(!result.error) result.error = 'Unknown solver error';
             console.log(`Solver status: ${result.status} - ${result.error}`);
           }
           // Objective value.
-          result.obj = sol.SolutionInfo.ObjVal;
+          result.obj = sol.SolutionInfo.ObjVal || 0;
           // Values of solution vector.
           if(sol.Vars) {
             // Fill dictionary with variable name: value entries.
@@ -676,21 +682,29 @@ module.exports = class MILPSolver {
         if(result.status.indexOf('OPTIMAL') >= 0) {
           result.status = 0;
           result.error = '';
+        } else if(result.status.indexOf('DUAL_INFEASIBLE') >= 0) {
+          result.error = 'Problem is unbounded';
+          solved = false;
+        } else if(result.status.indexOf('INFEASIBLE') >= 0) {
+          result.error = 'Problem is infeasible';
+          solved = false;
         }
-        while(i < output.length && output[i].indexOf('VARIABLES') < 0) {
-          i++;
-        }
-        // Fill dictionary with variable name: value entries.
-        while(i < output.length) {
-          const m = output[i].match(/^\d+\s+X(\d+)\s+SB\s+([^\s]+)\s+/);
-          if(m !== null)  {
-            const vn = 'X' + m[1].padStart(7, '0');
-            x_dict[vn] = parseFloat(m[2]);
+        if(solved) {
+          while(i < output.length && output[i].indexOf('VARIABLES') < 0) {
+            i++;
           }
-          i++;
+          // Fill dictionary with variable name: value entries.
+          while(i < output.length) {
+            const m = output[i].match(/^\d+\s+X(\d+)\s+\w\w\s+([^\s]+)\s+/);
+            if(m !== null)  {
+              const vn = 'X' + m[1].padStart(7, '0');
+              x_dict[vn] = parseFloat(m[2]);
+            }
+            i++;
+          }
+          // Fill the solution vector, adding 0 for missing columns.
+          getValuesFromDict();
         }
-        // Fill the solution vector, adding 0 for missing columns.
-        getValuesFromDict();
       } else {
         console.log('No solution found');
       }
@@ -698,6 +712,14 @@ module.exports = class MILPSolver {
       result.seconds = 0;
       const
           no_license = (log.indexOf('No license found') >= 0),
+          // NOTE: Omit first letter U, I and P as they may be either in
+          // upper case or lower case.
+          unbounded = (log.indexOf('nbounded') >= 0),
+          infeasible = (log.indexOf('nfeasible') >= 0),
+          primal_unbounded = (log.indexOf('rimal unbounded') >= 0),
+          err = log.match(/CPLEX Error\s+(\d+):\s+(.+)\./),
+          err_nr = (err && err.length > 1 ? parseInt(err[1]) : 0),
+          err_msg = (err_nr ? err[2] : ''),
           // NOTE: Solver reports time with 1/100 secs precision.
           mst = log.match(/Solution time \=\s+(\d+\.\d+) sec/);
       if(mst && mst.length > 1) result.seconds = parseFloat(mst[1]);
@@ -712,6 +734,15 @@ module.exports = class MILPSolver {
         // Non-zero solver exit code indicates serious trouble.
         result.error = 'CPLEX solver terminated with error';
         result.status = -13;
+      } else if(err_nr) {
+        result.status = err_nr;
+        if(infeasible && !primal_unbounded) {
+          result.error = 'Problem is infeasible';
+        } else if(unbounded) {
+          result.error = 'Problem is unbounded';
+        } else {
+          result.error = err_msg;
+        }
       } else {
         try {
           output = fs.readFileSync(s.solution, 'utf8').trim();
@@ -792,7 +823,14 @@ module.exports = class MILPSolver {
               }
             }
             if(result.status) {
-              result.error = this.solver_list.scip.errors[result.status];
+              let msg = s.statusMessage(result.status);  
+              if(msg) {
+                // If solver exited with known status code, report message.
+                result.solution = s.usableSolution(result.status);
+                result.error = msg;
+              }
+              if(!result.error) result.error = 'Unknown solver error';
+              console.log(`Solver status: ${result.status} - ${result.error}`);
             }
           } else if (m.startsWith('Solving Time')) {
             result.seconds = parseFloat(m.split(':')[1]);

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

@@ -104,6 +104,7 @@ class LinnyRModel {
     this.preferred_solver = ''; // empty string denotes "use default"
     this.integer_tolerance = 5e-7; // integer feasibility tolerance
     this.MIP_gap = 1e-4; // relative MIP gap
+    this.always_diagnose = false;
 
     // Sensitivity-related properties
     this.base_case_selectors = '';
@@ -2666,6 +2667,7 @@ class LinnyRModel {
       this.infer_cost_prices = nodeParameterValue(node, 'cost-prices') === '1';
       this.report_results = nodeParameterValue(node, 'report-results') === '1';
       this.show_block_arrows = nodeParameterValue(node, 'block-arrows') === '1';
+      this.always_diagnose = nodeParameterValue(node, 'diagnose') === '1';
       this.name = xmlDecoded(nodeContentByTag(node, 'name'));
       this.author = xmlDecoded(nodeContentByTag(node, 'author'));
       this.comments = xmlDecoded(nodeContentByTag(node, 'notes'));
@@ -3014,6 +3016,7 @@ class LinnyRModel {
     if(this.infer_cost_prices) p += ' cost-prices="1"';
     if(this.report_results) p += ' report-results="1"';
     if(this.show_block_arrows) p += ' block-arrows="1"';
+    if(this.always_diagnose) p += ' diagnose="1"';
     let xml = this.xml_header + ['<model', p, '><name>',  xmlEncoded(this.name),
         '</name><author>', xmlEncoded(this.author),
         '</author><notes>', xmlEncoded(this.comments),
@@ -6302,7 +6305,9 @@ class Cluster extends NodeBox {
   }
   
   usesSlack(t, p, slack_type) {
-    // Adds slack-using product `p` to slack info for this cluster
+    // Adds slack-using product `p` to slack info for this cluster.
+    // NOTE: When diagnosing an unbounded problem, `p` can also be a
+    // process with an infinite level.
     let s;
     if(t in this.slack_info) {
       s = this.slack_info[t];
@@ -6311,6 +6316,7 @@ class Cluster extends NodeBox {
       this.slack_info[t] = s;
     }
     addDistinct(p, s[slack_type]);
+    // NOTE: Recursive call to let the slack use info "bubble up".
     if(this.cluster) this.cluster.usesSlack(t, p, slack_type);
   }
 

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

@@ -2078,6 +2078,15 @@ class VirtualMachine {
     // so far, type is always HI (highest increment); object can be
     // a process or a product.
     this.chunk_variables = [];
+    // NOTE: As of version 1.8.0, diagnosis is performed only when the
+    // modeler Alt-clicks the "run" button or clicks the link in the
+    // infoline warning that is displayed when the solver reports that a
+    // block poses a problem that is infeasible (too tight constraints)
+    // or unbounded (no upper limit on some processes). Diagnosis is
+    // implemented by adding slack and setting finite bounds on processes
+    // and then make a second attempt to solve the block.
+    this.diagnose = false;
+    this.prompt_to_diagnose = false;
     // Array for VM instructions.
     this.code = [];
     // The Simplex tableau: matrix, rhs and ct will have same length.
@@ -2112,17 +2121,23 @@ class VirtualMachine {
     // Floating-point constants used in calculations
     // Meaningful solver results are assumed to lie wihin reasonable bounds.
     // Extreme absolute values (10^25 and above) are used to signal particular
-    // outcomes. This 10^25 limit is used because the default MILP solver
-    // LP_solve considers a problem to be unbounded if decision variables
-    // reach +INF (1e+30) or -INF (-1e+30), and a solution inaccurate if
-    // extreme values get too close to +/-INF. The higher values have been
-    // chosen arbitrarily.
+    // outcomes. This 10^25 limit is used because the original MILP solver
+    // used by Linny-R (LP_solve) considers a problem to be unbounded if
+    // decision variables reach +INF (1e+30) or -INF (-1e+30), and a solution
+    // inaccurate if extreme values get too close to +/-INF. The higher
+    // values have been chosen arbitrarily.
     this.PLUS_INFINITY = 1e+25;
     this.MINUS_INFINITY = -1e+25;
     this.BEYOND_PLUS_INFINITY = 1e+35;
     this.BEYOND_MINUS_INFINITY = -1e+35;
+    // The 1e+30 value is recognized by all supported solvers as "infinity",
+    // and hence can be used to indicate that a variable has no upper bound.
     this.SOLVER_PLUS_INFINITY = 1e+30;
     this.SOLVER_MINUS_INFINITY = -1e+30;
+    // As of version 1.8.0, Linny-R imposes no +INF bounds on processes
+    // unless diagnosing an unbounded problem. For such diagnosis, the
+    // (relatively) low value 9.99999999e+9 is used.
+    this.DIAGNOSIS_UPPER_BOUND = 9.99999999e+9;
     // NOTE: Below the "near zero" limit, a number is considered zero
     // (this is to timely detect division-by-zero errors).
     this.NEAR_ZERO = 1e-10;
@@ -2345,17 +2360,6 @@ class VirtualMachine {
   selectSolver(id) {
     if(id in this.solver_names) {
       this.solver_id = id;
-/*
-      if(id === 'mosek') {
-        this.PLUS_INFINITY = 1e+6;
-        this.MINUS_INFINITY = -1e+6;
-        this.MAX_SLACK_PENALTY = 1e+6;
-      } else {
-        this.PLUS_INFINITY = 1e+25;
-        this.PLUS_INFINITY = -1e+25;
-        this.MAX_SLACK_PENALTY = 1e+24;
-      }
-*/
     } else {
       UI.alert(`Invalid solver ID "${id}"`);
     }
@@ -2996,7 +3000,7 @@ class VirtualMachine {
     //     to respect certain constraints. This may result in infeasible
     //     MILP problems. The solver will report this, but provide no
     //     clue as to which constraints may be critical.
-    if(p instanceof Product && !p.no_slack) {
+    if(p instanceof Product && this.diagnose && !p.no_slack) {
       p.stock_LE_slack_var_index = this.addVariable('LE', p);
       p.stock_GE_slack_var_index = this.addVariable('GE', p);
     }
@@ -3125,7 +3129,7 @@ class VirtualMachine {
       );
     // ... or if P is neither source nor sink.
     } else if(p.equal_bounds && notsrc && notsnk) {
-      if(!p.no_slack) {
+      if(this.diagnose && !p.no_slack) {
         // NOTE: For EQ, both slack variables should be used, having
         // respectively -1 and +1 as coefficients.
         this.code.push(
@@ -3141,7 +3145,7 @@ class VirtualMachine {
     } else {
       // Add lower bound (GE) constraint unless product is a source node.
       if(notsrc) {
-        if(!p.no_slack) {
+        if(this.diagnose && !p.no_slack) {
           // Add the GE slack index with coefficient +1 (so it can
           // INcrease the left-hand side of the equation)
           this.code.push([VMI_add_const_to_coefficient, [gesvi, 1]]);
@@ -3154,7 +3158,7 @@ class VirtualMachine {
       }
       // Add upper bound (LE) constraint unless product is a sink node
       if(notsnk) {
-        if(!p.no_slack) {
+        if(this.diagnose && !p.no_slack) {
           // Add the stock LE index with coefficient -1 (so it can
           // DEcrease the LHS).
           this.code.push([VMI_add_const_to_coefficient, [lesvi, -1]]);
@@ -3189,6 +3193,14 @@ class VirtualMachine {
       this.fixed_var_indices.push([]);
     }
     
+    // Log if run is performed in "diagnosis" mode.
+    if(this.diagnose) {
+      this.logMessage(this.block_count, 'DIAGNOSTIC RUN' +
+          (MODEL.always_diagnose ? ' (default -- see model settings)': '') +
+          '\n- slack variables on products and constraints' +
+          '\n- finite bounds on all processes');
+    }
+    
     // Just in case: re-determine which entities can be ignored.
     MODEL.inferIgnoredEntities();
     const n = Object.keys(MODEL.ignored_entities).length;
@@ -3254,7 +3266,7 @@ class VirtualMachine {
             // solver does not support special ordered sets).
             // NOTE: `addVariable` will add as many as there are points!
             bl.first_sos_var_index = this.addVariable('W1', bl);
-            if(!c.no_slack) {
+            if(this.diagnose && !c.no_slack) {
               // Define the slack variable(s) for bound line constraints.
               // NOTE: Category [2] means: highest slack penalty.
               if(bl.type !== VM.GE) {
@@ -3375,7 +3387,7 @@ class VirtualMachine {
         p = MODEL.products[k];
         // Get index of variable that is constrained by LB and UB.
         vi = p.level_var_index;
-        if(p.no_slack) {
+        if(p.no_slack || !this.diagnose) {
           // If no slack, the bound constraints can be set on the
           // variables themselves.
           lbx = p.lower_bound;
@@ -3658,7 +3670,7 @@ class VirtualMachine {
       k = product_keys[i];
       if(!MODEL.ignored_entities[k]) {
         p = MODEL.products[k];
-        if(p.level_var_index >= 0 && !p.no_slack) {
+        if(p.level_var_index >= 0 && !p.no_slack && this.diagnose) {
           hb = p.hasBounds;
           pen = (p.is_data ? 2 :
               // NOTE: Lowest penalty also for IMPLIED sources and sinks.
@@ -4605,7 +4617,8 @@ class VirtualMachine {
       // Compute the peak from the peak increase.
       p.b_peak[block] = p.b_peak[block - 1] + p.b_peak_inc[block];
     }
-    // Add warning to messages if slack has been used.
+    // Add warning to messages if slack has been used, or some process
+    // level is "infinite" while diagnosing an unbounded problem.
     // NOTE: Only check after the last round has been evaluated.
     if(round === this.lastRound) {
       let b = bb;
@@ -4646,6 +4659,27 @@ class VirtualMachine {
             }
           }
         }
+        if(this.diagnose) {
+          // Iterate over all processes, and set the "slack use" flag
+          // for their cluster so that these clusters will be highlighted.
+          for(let o in MODEL.processes) if(MODEL.processes.hasOwnProperty(o) &&
+              !MODEL.ignored_entities[o]) {
+            const
+                p = MODEL.processes[o],
+                l = p.level[b];
+            if(l >= VM.PLUS_INFINITY) {
+              this.logMessage(block,
+                  `${this.WARNING}(t=${b}${round}) ${p.displayName} has level +INF`);
+              // NOTE: +INF is signalled in blue, just like use of LE slack.
+              p.cluster.usesSlack(b, p, 'LE');
+            } else if(l <= VM.MINUS_INFINITY) {
+              this.logMessage(block,
+                  `${this.WARNING}(t=${b}${round}) ${p.displayName} has level -INF`);
+              // NOTE: -INF is signalled in red, just like use of GE slack.
+              p.cluster.usesSlack(b, p, 'GE');
+            }
+          }
+        }
         j += this.cols;
         b++;
       }
@@ -5878,6 +5912,9 @@ Solver status = ${json.status}`);
       }
       this.logMessage(bnr, errmsg);
       UI.alert(errmsg);
+      if(errmsg.indexOf('nfeasible') >= 0 || errmsg.indexOf('nbounded') >= 0) {
+        this.prompt_to_diagnose = true;
+      }
     }
     this.logMessage(bnr, msg);
     this.equations[bnr - 1] = json.model;
@@ -5936,7 +5973,12 @@ Solver status = ${json.status}`);
         RECEIVER.report();
       }
       // Warn modeler if any issues occurred.
-      if(this.block_issues) {
+      if(this.prompt_to_diagnose && !this.diagnose) {
+        UI.warn('Model is infeasible or unbounded -- ' +
+            '<strong>Alt</strong>-click on the <em>Run</em> button ' +
+            '<img id="solve-btn" class="sgray" src="images/solve.png">' +
+            ' for diagnosis');
+      } else if(this.block_issues) {
         let msg = 'Issues occurred in ' +
             pluralS(this.block_issues, 'block') +
             ' -- details can be viewed in the monitor';
@@ -6091,7 +6133,7 @@ Solver status = ${json.status}`);
     this.solveBlocks();
   }
   
-  solveModel() {
+  solveModel(diagnose=false) {
     // Start the sequence of data loading, model translation, solving
     // consecutive blocks, and finally calculating dependent variables.
     // NOTE: Do this only if the model defines a MILP problem, i.e.,
@@ -6101,6 +6143,22 @@ Solver status = ${json.status}`);
       UI.notify('Nothing to solve');
       return;
     }
+    // Diagnosis (by adding slack variables and finite bounds on processes)
+    // is activated when Alt-clicking the "run" button, or by clicking the
+    // "clicke HERE to diagnose" link on the infoline.
+    this.diagnose = diagnose || MODEL.always_diagnose;
+    if(this.diagnose) {
+      this.PLUS_INFINITY = this.DIAGNOSIS_UPPER_BOUND;
+      this.MINUS_INFINITY = -this.DIAGNOSIS_UPPER_BOUND;
+      console.log('DIAGNOSIS ON');
+    } else {
+      this.PLUS_INFINITY = 1e+25;
+      this.MINUS_INFINITY = -1e+25;
+      console.log('DIAGNOSIS OFF');
+    }
+    // The "propt to diagnose" flag is set when some block posed an
+    // infeasible or unbounded problem.
+    this.prompt_to_diagnose = false;
     const n = MODEL.loading_datasets.length;
     if(n > 0) {
       // Still within reasonable time? (3 seconds per dataset)
@@ -7784,10 +7842,11 @@ function VMI_set_bounds(args) {
       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);
+      // When diagnosing an unbounded problem, use low value for INFINITY,
+      // but the optional fourth parameter indicates whether the solver's
+      // infinity values should override the diagnosis INFINITY.
+      inf_val = (VM.diagnose && !(args.length > 3 && args[3]) ?
+          VM.DIAGNOSIS_UPPER_BOUND : VM.SOLVER_PLUS_INFINITY);
   let l,
       u,
       fixed = (vi in VM.fixed_var_indices[r - 1]);
@@ -7812,17 +7871,15 @@ function VMI_set_bounds(args) {
     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;
-    }
+    if(l === VM.MINUS_INFINITY) l = -inf_val;
+    if(u === VM.PLUS_INFINITY) u = inf_val;
     fixed = '';
   }
   // NOTE: To see in the console whether fixing across rounds works, insert
   // "fixed !== '' || " before DEBUGGING below.
   if(DEBUGGING) {
     console.log(['set_bounds [', k, '] ', vbl.displayName, ' t = ', VM.t,
-      ' LB = ', VM.sig4Dig(l), ', UB = ', VM.sig4Dig(u), fixed].join(''));
+      ' LB = ', VM.sig4Dig(l), ', UB = ', VM.sig4Dig(u), fixed, l, u, inf_val].join(''));
   }
   // NOTE: Since the VM vectors for lower bounds and upper bounds are
   // initialized with default values (0 for LB, +INF for UB), there is
@@ -8327,7 +8384,15 @@ function VMI_add_constraint(ct) {
       }
     }
     VM.matrix.push(row);
-    VM.right_hand_side.push(VM.rhs);
+    let rhs = VM.rhs;
+    if(rhs >= VM.PLUS_INFINITY) {
+      rhs = (VM.diagnose ? VM.DIAGNOSIS_UPPER_BOUND :
+          VM.SOLVER_PLUS_INFINITY);
+    } else if(rhs <= VM.MINUS_INFINITY) {
+      rhs = (VM.diagnose ? -VM.DIAGNOSIS_UPPER_BOUND :
+          VM.SOLVER_MINUS_INFINITY);
+    }
+    VM.right_hand_side.push(rhs);
     VM.constraint_types.push(ct);
   } else if(DEBUGGING) {
     console.log('Constraint NOT added!');
@@ -8480,7 +8545,7 @@ function VMI_add_bound_line_constraint(args) {
   for(let i = 0; i < w.length; i++) {
     VM.coefficients[w[i]] = -y[i];
   }
-  if(!bl.constraint.no_slack) {
+  if(VM.diagnose && !bl.constraint.no_slack) {
     // Add coefficients for slack variables unless omitted.
     if(bl.type != VM.LE) VM.coefficients[VM.offset + bl.GE_slack_var_index] = 1;
     if(bl.type != VM.GE) VM.coefficients[VM.offset + bl.LE_slack_var_index] = -1;