linny-r 1.9.0 → 1.9.2

package/package.json

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

package/static/index.html

@@ -750,6 +750,13 @@ NOTE: Unit symbols are case-sensitive, so BTU ≠ Btu">
                    placeholder="1e-4" type="text" autocomplete="off">
           </td>
         </tr>
+        <tr title="When checked, small slack uses are reported in monitor">
+          <td style="padding: 0px; width: 20px">
+            <div id="solver-show-notices" class="box clear"></div>
+          </td>
+          <td style="padding-bottom:4px">Report small slack uses</td>
+          </td>
+        </tr>
       </table>
     </div>
   </div>

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

@@ -3689,6 +3689,7 @@ console.log('HERE name conflicts', name_conflicts, mapping);
     md.element('preference').innerHTML = html.join('');
     md.element('int-feasibility').value = MODEL.integer_tolerance;
     md.element('mip-gap').value = MODEL.MIP_gap;
+    this.setBox('solver-show-notices', MODEL.show_notices);
     md.show();
   }
   
@@ -3717,6 +3718,7 @@ console.log('HERE name conflicts', name_conflicts, mapping);
     }
     MODEL.integer_tolerance = Math.max(1e-9, Math.min(0.1, itol));
     MODEL.MIP_gap = Math.max(0, Math.min(0.5, mgap));
+    MODEL.show_notices = this.boxChecked('solver-show-notices');
     // Close the dialog.
     md.hide();
   }

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

@@ -66,6 +66,7 @@ Attributes, however, are case sensitive!">[Actor X|CF]</code> for cash flow.
   <code title="Relative time step (t &minus; t&#8320; + 1)">rt</code>,
   <code title="Number of current block">b</code>,
   <code title="Time step within current block">bt</code>,
+  <code title="Time step within current chunk">ct</code>,
   <code title="Duration of 1 time step (in hours)">dt</code>,
   <code title="Run length (# time steps)">N</code>,
   <code title="Block length (# time steps)">n</code>,

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

@@ -107,6 +107,7 @@ class LinnyRModel {
     this.integer_tolerance = 5e-7; // integer feasibility tolerance
     this.MIP_gap = 1e-4; // relative MIP gap
     this.always_diagnose = true;
+    this.show_notices = true;
 
     // Sensitivity-related properties
     this.base_case_selectors = '';
@@ -2670,6 +2671,7 @@ class LinnyRModel {
       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.show_notices = nodeParameterValue(node, 'show-notices') === '1';
       this.name = xmlDecoded(nodeContentByTag(node, 'name'));
       this.author = xmlDecoded(nodeContentByTag(node, 'author'));
       this.comments = xmlDecoded(nodeContentByTag(node, 'notes'));
@@ -3023,6 +3025,7 @@ class LinnyRModel {
     if(this.report_results) p += ' report-results="1"';
     if(this.show_block_arrows) p += ' block-arrows="1"';
     if(this.always_diagnose) p += ' diagnose="1"';
+    if(this.show_notices) p += ' show-notices="1"';
     let xml = this.xml_header + ['<model', p, '><name>',  xmlEncoded(this.name),
         '</name><author>', xmlEncoded(this.author),
         '</author><notes>', xmlEncoded(this.comments),

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

@@ -430,20 +430,25 @@ class Expression {
   }
 
   result(t, number=false) {
-    // Computes (only if needed) and then returns result for time step t
+    // Compute (only if needed) and then returns result for time step t.
     // The `number` is passed only by the VMI_push_dataset_modifier
-    // instruction so as to force recomputation of the expression
-    // NOTE: for t < 1 return the value for t = 1, since expressions have no
-    // "initial value" (these follow from the variables used in the expression)
-    // Select the vector to use
+    // instruction so as to force recomputation of the expression.
+    // Select the vector to use.
     const v = this.chooseVector(number);
     if(!Array.isArray(v)) {
       console.log('ANOMALY: No vector for result(t)');
       return VM.UNDEFINED;
     }
+    // NOTE: For t < 1 return the value for t = 1, since expressions have
+    // no "initial value" (these follow from the variables used in the
+    // expression).
     if(t < 0 || this.isStatic) t = 0;
     if(t >= v.length) return VM.UNDEFINED;
-    if(v[t] === VM.NOT_COMPUTED || v[t] === VM.COMPUTING) {
+    // NOTE: When VM is setting up a tableau, values computed for the
+    // look-ahead period must be recomputed.
+    if(v[t] === VM.NOT_COMPUTED || v[t] === VM.COMPUTING ||
+      (!this.isStatic && VM.inLookAhead(t))) {
+      v[t] = VM.NOT_COMPUTED;
       this.compute(t, number);
     }
     // NOTE: when this expression is the "active" parameter for sensitivity
@@ -2477,8 +2482,19 @@ class VirtualMachine {
     this.t = 0;
     // Prepare for halt.
     this.halted = false;
+    // Flag to indicate that VM is executing its tableau construction code.
+    // This affects how chunk time (ct) is computed, and whether expression
+    // results must be recomputed (see inLookAhead below).
+    this.executing_tableau_code = false;
     UI.readyToSolve();
   }
+  
+  inLookAhead(t) {
+    // Return TRUE if VM is executing its tableau construction code AND
+    // time step `t` falls in the look-ahead period of the previous block.
+    return this.executing_tableau_code &&
+        t - (this.block_count - 1) * MODEL.block_length <= MODEL.look_ahead;
+  }
 
   errorMessage(n) {
     // VM errors are very big NEGATIVE numbers, so start comparing `n`
@@ -2551,7 +2567,7 @@ class VirtualMachine {
     return Math.round(n);
   }
   
-  sig4Dig(n) {
+  sig4Dig(n, tiny=false) {
     // Return number `n` formatted so as to show 4-5 significant digits.
     // NOTE: As `n` should be a number, a warning sign will typically
     // indicate a bug in the software.
@@ -2560,8 +2576,13 @@ class VirtualMachine {
     // If `n` has a special value, return its representation.
     if(sv[0]) return sv[1];
     const a = Math.abs(n);
+    if(a === 0) return 0;
     // Signal small differences from true 0 by a leading + or - sign.
-    if(n !== 0 && a <= this.ON_OFF_THRESHOLD) return n > 0 ? '+0' : '-0';
+    if(a <= this.ON_OFF_THRESHOLD) {
+      // The `tiny` flag indicates: display small number in E-notation.
+      if(tiny) return n.toPrecision(1);
+      return n > 0 ? '+0' : '-0';
+    }
     if(a >= 9999995) return n.toPrecision(4);
     if(Math.abs(a-Math.round(a)) < 0.0005) return Math.round(n);
     if(a < 1) return Math.round(n*10000) / 10000;
@@ -2871,7 +2892,7 @@ class VirtualMachine {
         const
             bm = r.block_messages[i],
             err = (bm.messages.indexOf('Solver status = 0') < 0 ||
-                bm.messages.indexOf('Warning') >= 0);
+                bm.messages.indexOf(this.WARNING) >= 0);
         this.solver_times.push(bm.solver_time);
         this.messages.push(bm.messages);
         this.variables.push(this.no_variables);
@@ -4650,14 +4671,16 @@ class VirtualMachine {
               }
               if(b <= this.nr_of_time_steps && absl > VM.ON_OFF_THRESHOLD) {
                 this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
-                    `${v[1].displayName} ${v[0]} slack = ${this.sig4Dig(slack)}`);
+                    `${v[1].displayName} ${v[0]} slack = ` +
+                    // NOTE: TRUE denotes "show tiny values with precision".
+                    this.sig4Dig(slack, true));
                 if(v[1] instanceof Product) {
                   const ppc = v[1].productPositionClusters;
                   for(let ci = 0; ci < ppc.length; ci++) {
                     ppc[ci].usesSlack(b, v[1], v[0]);
                   }
                 }
-              } else if(CONFIGURATION.slight_slack_notices) {
+              } else if(MODEL.show_notices) {
                 this.logMessage(block, '---- Notice: (t=' + b + round + ') ' +
                    v[1].displayName + ' ' + v[0] + ' slack = ' +
                    slack.toPrecision(1));
@@ -5223,7 +5246,7 @@ class VirtualMachine {
   }
   
   addTableauSegment(start, abl) {
-    if(VM.halted) {
+    if(this.halted) {
       this.hideSetUpOrWriteProgress();
       this.stopSolving();
       return;
@@ -5233,6 +5256,7 @@ class VirtualMachine {
     var l;
     const next_start = (start + this.tsl * 1.2 < abl ? start + this.tsl : abl);
     for(let i = start; i < next_start; i++) {
+      this.executing_tableau_code = true;
       this.logTrace('EXECUTE for t=' + this.t);
       l = this.code.length;
       for(let j = 0; j < l; j++) {
@@ -5244,6 +5268,7 @@ class VirtualMachine {
         this.logTrace([('    ' + j).slice(-5), ': coeff = ',
             JSON.stringify(this.coefficients), ';  rhs = ', this.rhs].join(''));
       }
+      this.executing_tableau_code = false;
       this.logTrace('STOP executing block code');
       // Add constraints for paced process variables.
       // NOTE: This is effectuated by *executing* VM instructions.
@@ -6268,11 +6293,26 @@ function VMI_push_block_time(x) {
   const
       lt = x.step[x.step.length - 1] - 1,
       bnr = Math.floor(lt / MODEL.block_length),
-      t = lt - bnr * MODEL.block_length + 1; 
+      t = lt - bnr * MODEL.block_length + 1;
   if(DEBUGGING) console.log('push block time bt = ' + t);
   x.push(t);
 }
 
+function VMI_push_chunk_time(x) {
+  // Push the time step for which the VM is preparing the tableau.
+  // NOTE: Chunk time is meaningful only while the VM is solving a block.
+  // If not, the block time is pushed.
+  if(VM.executing_tableau_code) {
+    const
+        ct = VM.t - (VM.block_count - 1) * MODEL.block_length;
+    if(DEBUGGING) console.log('push chunk time ct = ' + ct);
+    x.push(ct);
+  } else {
+    if(DEBUGGING) console.log('push chunk time: NOT constructing tableau'); 
+    VMI_push_block_time(x);    
+  }
+}
+
 function VMI_push_block_number(x) {
   // Push the number of the block currently being optimized.
   // NOTE: Block numbering starts at 1.
@@ -6549,28 +6589,32 @@ function relativeTimeStep(t, anchor, offset, dtm, x) {
     // Offset relative to current time step, scaled to time unit of run.
     return Math.floor((t + offset) * dtm);
   }
+  if(anchor === 'f') {
+    // Last: offset relative to index  1 in the vector.
+    return 1 + offset;
+  }
+  if(anchor === 'l') {
+    // Last: offset relative to the last index in the vector.
+    return VM.nr_of_time_steps + offset;
+  }
+  const cb = Math.trunc((t - 1) / MODEL.block_length);
   if(anchor === 'c') {
     // Relative to start of current optimization block.
-    return Math.trunc(t / MODEL.block_length) * MODEL.block_length + offset;
+    return cb * MODEL.block_length + 1 + offset;
   }
   if(anchor === 'p') {
     // Relative to start of previous optimization block.
-    return (Math.trunc(t / MODEL.block_length) - 1) * MODEL.block_length + offset;
+    return (cb - 1) * MODEL.block_length + 1 + offset;
   }
   if(anchor === 'n') {
     // Relative to start of next optimization block.
-    return (Math.trunc(t / MODEL.block_length) + 1) * MODEL.block_length + offset;
-  }
-  if(anchor === 'l') {
-    // Last: offset relative to the last index in the vector.
-    return VM.nr_of_time_steps + offset;
+    return (cb + 1) * MODEL.block_length + 1 + offset;
   }
   if(anchor === 's') {
     // Scaled: offset is scaled to time unit of run.
     return Math.floor(offset * dtm);
   }
   // Fall-through: offset relative to the initial value index (0).
-  // NOTE: this also applies to anchor f (First).
   return offset;
 }
 
@@ -7088,7 +7132,8 @@ function VMI_push_statistic(x, args) {
   t2 = Math.max(0, Math.min(tmax, t2));
   // Trace only now that time step range has been computed
   if(DEBUGGING) {
-    const trc = ['push statistic: [', stat, ': N = ', list.length, ']', ao1, ao2];
+    const trc = ['push statistic: [', stat, ': N = ', list.length, ']',
+        ao1, ao2, ' (t = ', t1, '-', t2, ')'];
     console.log(trc.join(''));
   }
   // Establish whether statistic pertains to non-zero values only
@@ -7124,7 +7169,7 @@ function VMI_push_statistic(x, args) {
   const
       n = vlist.length,
       // NOTE: count is the number of values used in the statistic 
-      count = (nz ? n : list.length);
+      count = (nz ? n : list.length * (t2 - t1 + 1));
   if(stat === 'N') {
     x.push(count);
     return;
@@ -8683,11 +8728,12 @@ const
   SEPARATOR_CHARS = PARENTHESES + OPERATOR_CHARS + "[ '",
   COMPOUND_OPERATORS = ['!=', '<>', '>=', '<='],
   CONSTANT_SYMBOLS = [
-      't', 'rt', 'bt', 'b', 'N', 'n', 'l', 'r', 'lr', 'nr', 'x', 'nx',
+      't', 'rt', 'bt', 'ct', 'b', 'N', 'n', 'l', 'r', 'lr', 'nr', 'x', 'nx',
       'random', 'dt', 'true', 'false', 'pi', 'infinity', '#',
       'i', 'j', 'k', 'yr', 'wk', 'd', 'h', 'm', 's'],
   CONSTANT_CODES = [
       VMI_push_time_step, VMI_push_relative_time, VMI_push_block_time,
+      VMI_push_chunk_time,
       VMI_push_block_number, VMI_push_run_length, VMI_push_block_length,
       VMI_push_look_ahead, VMI_push_round, VMI_push_last_round,
       VMI_push_number_of_rounds, VMI_push_run_number, VMI_push_number_of_runs,
@@ -8696,7 +8742,7 @@ const
       VMI_push_i, VMI_push_j, VMI_push_k,
       VMI_push_year, VMI_push_week, VMI_push_day, VMI_push_hour,
       VMI_push_minute, VMI_push_second],
-  DYNAMIC_SYMBOLS = ['t', 'rt', 'bt', 'b', 'r', 'random', 'i', 'j', 'k'],
+  DYNAMIC_SYMBOLS = ['t', 'rt', 'bt', 'ct', 'b', 'r', 'random', 'i', 'j', 'k'],
   MONADIC_OPERATORS = [
       '~', 'not', 'abs', 'sin', 'cos', 'atan', 'ln',
       'exp', 'sqrt', 'round', 'int', 'fract', 'min', 'max',