linny-r 1.6.1 → 1.6.2

package/package.json

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

package/server.js

@@ -1521,7 +1521,7 @@ function connectionErrorText(msg) {
 //
 
 function commandLineSettings() {
-  // Sets default settings, and then checks the command line arguments
+  // Sets default settings, and then checks the command line arguments.
   const settings = {
       cli_name: (PLATFORM.startsWith('win') ? 'Command Prompt' : 'Terminal'),
       inkscape: '',
@@ -1533,6 +1533,22 @@ function commandLineSettings() {
       solver_path: '',
       user_dir: path.join(WORKING_DIRECTORY, 'user')
     };
+  const
+      cmd = process.argv[0],
+      app = (cmd.endsWith('node.exe') ? 'node' : 'linny-r'),
+      usage = `Usage:  ${app} server [options]
+
+Possible options are:
+  dpi=[number]       will make InkScape render SVGs in the specified resolution
+  help               will display these command line options
+  launch             will open the Linny-R GUI in a browser window
+  port=[number]      will listen at the specified port number
+                     (default is 5050; number must be unique for each server)
+  solver=[name]      will select solver [name], or warn if not found
+                     (name choices: Gurobi, CPLEX, SCIP or LP_solve)
+  verbose            will output solver messages to the console
+  workspace=[path]   will create workspace in [path] instead of (Linny-R)/user
+`;
   for(let i = 2; i < process.argv.length; i++) {
     const lca = process.argv[i].toLowerCase();
     if(lca === 'launch') {
@@ -1541,7 +1557,7 @@ function commandLineSettings() {
       const av = lca.split('=');
       if(av.length === 1) av.push('');
       if(av[0] === 'port') {
-        // Accept any number greater than or equal to 1024
+        // Accept any number greater than or equal to 1024.
         const n = parseInt(av[1]);
         if(isNaN(n) || n < 1024) {
           console.log(`WARNING: Invalid port number ${av[1]}`);
@@ -1555,7 +1571,7 @@ function commandLineSettings() {
           settings.preferred_solver = av[1];
         }
       } else if(av[0] === 'dpi') {
-        // Accept any number greater than or equal to 1024
+        // Accept any number greater than or equal to 1024.
         const n = parseInt(av[1]);
         if(isNaN(n) || n > 1200) {
           console.log(`WARNING: Invalid resolution ${av[1]} (max. 1200 dpi)`);
@@ -1563,7 +1579,7 @@ function commandLineSettings() {
           settings.dpi = n;
         }
       } else if(av[0] === 'workspace') {
-        // User directory must be READ/WRITE-accessible
+        // User directory must be READ/WRITE-accessible.
         try {
           fs.accessSync(av[1], fs.constants.R_OK | fs.constants.W_O);
         } catch(err) {
@@ -1571,10 +1587,15 @@ function commandLineSettings() {
           process.exit();
         }
         settings.user_dir = av[1];
+      } else if(av[0] === 'help') {
+        // Print command line options.
+        console.log(usage);
+        process.exit();
       } else {
-        // Terminate script
+        // Terminate script.
         console.log(
-            `ERROR: Invalid command line argument "${process.argv[i]}"`);
+            `ERROR: Invalid command line argument "${process.argv[i]}"\n`);
+        console.log(usage);
         process.exit();
       }
     }

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

@@ -356,7 +356,11 @@ class GUIExperimentManager extends ExperimentManager {
     dim_count.innerHTML = pluralS(x.available_dimensions.length,
         'more dimension');
     x.inferActualDimensions();
+    for(let i = 0; i < x.actual_dimensions.length; i++) {
+      x.actual_dimensions[i].sort(compareSelectors);
+    }
     x.inferCombinations();
+    //x.combinations.sort(compareCombinations);
     combi_count.innerHTML = pluralS(x.combinations.length, 'combination');
     if(x.combinations.length === 0) canview = false;
     header.innerHTML = x.title;
@@ -850,6 +854,9 @@ class GUIExperimentManager extends ExperimentManager {
       }
       // Get the selected statistic for each run so as to get an array of numbers
       const data = [];
+      // Set reference column indices so that values for the reference|
+      // configuration can be displayed in orange.
+      const ref_conf_indices = [];
       for(let i = 0; i < x.runs.length; i++) {
         const
             r = x.runs[i],
@@ -878,7 +885,7 @@ class GUIExperimentManager extends ExperimentManager {
           data.push(rr.last);
         }
       }
-      // Scale data as selected
+      // Scale data as selected.
       const scaled = data.slice();
       // NOTE: scale only after the experiment has been completed AND
       // configurations have been defined (otherwise comparison is pointless)
@@ -896,7 +903,9 @@ class GUIExperimentManager extends ExperimentManager {
           }
           // Set difference for reference configuration itself to 0
           for(let i = 0; i < n; i++) {
-            scaled[rc * n + i] = 0;
+            const index = rc * n + i;
+            scaled[index] = 0;
+            ref_conf_indices.push(index);
           }
         } else if(x.selected_scale === 'reg') {
           // Compute regret: current config - high value config in same scenario
@@ -934,13 +943,15 @@ class GUIExperimentManager extends ExperimentManager {
         formatted.push(VM.sig4Dig(scaled[i]));
       }
       uniformDecimals(formatted);
-      // Display formatted data in cells
+      // Display formatted data in cells.
       for(let i = 0; i < x.combinations.length; i++) {
         const cell = document.getElementById('xr' + i);
         if(i < x.runs.length) {
           cell.innerHTML = formatted[i];
           cell.classList.remove('not-run');
           cell.style.backgroundColor = this.color_scale.rgb(normalized[i]);
+          cell.style.color = (ref_conf_indices.indexOf(i) >= 0 ?
+              'orange' : 'black');
           const
               r = x.runs[i],
               rr = r.results[rri],

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

@@ -2312,17 +2312,18 @@ class Paper {
     }
     if(prod.hasBounds) {
       font_color = 'black';
-      // By default, "plain" factors having bounds are filled in silver
+      // By default, "plain" factors having bounds are filled in silver.
       fill_color = this.palette.has_bounds;
       // Use relative distance to bounds so that 100000.1 is not shown
-      // as overflow, but 100.1 is
+      // as overflow, but 100.1 is.
       let udif = this.relDif(l, ub),
           ldif = this.relDif(lb, l);
-      // Special case: for LB = 0, use the ON/OFF threshold
+      // Special case: for LB = 0, use the ON/OFF threshold.
       if(Math.abs(lb) <= VM.SIG_DIF_LIMIT &&
           Math.abs(l) <= VM.ON_OFF_THRESHOLD) ldif = 0;
       if(MODEL.solved) {
-        // NOTE: use bright red and blue colors in case of "stock level out of bounds"
+        // NOTE: Use bright red and blue colors in case of "stock level
+        // out of bounds".
         if(ub < VM.PLUS_INFINITY && l < VM.UNDEFINED && udif > VM.SIG_DIF_LIMIT) {
           fill_color = this.palette.above_upper_bound;
           font_color = 'blue';
@@ -2332,51 +2333,52 @@ class Paper {
         } else if(l < VM.ERROR || l > VM.EXCEPTION) {
           font_color = this.palette.VM_error;
         } else if(l < VM.UNDEFINED) {
-          // Shades of green reflect whether level within bounds, where
+          // Shades of green reflect whether level is within bounds, where
           // "sources" (negative level) and "sinks" (positive level) are
-          // shown as more reddish / bluish shades of green
+          // shown as more reddish / bluish shades of green.
           if(l < -VM.ON_OFF_THRESHOLD) {
             fill_color = this.palette.neg_within_bounds;
           } else if(l > VM.ON_OFF_THRESHOLD) {
             fill_color = this.palette.pos_within_bounds;
           } else {
-              fill_color = this.palette.zero_within_bounds;
+            fill_color = this.palette.zero_within_bounds;
           }
           if(ub - lb < VM.NEAR_ZERO) {
+            // When LB = UB, fill completely in the color, but ...
             if(prod.isConstant && Math.abs(l) > VM.NEAR_ZERO) {
-              // Non-zero constants have less saturated shades
+              // ... non-zero constants have less saturated shades.
               fill_color = (l < 0 ? this.palette.neg_constant :
                   this.palette.pos_constant);  
             }
           } else if(ub - l < VM.SIG_DIF_LIMIT) {
-            // Black font and darker fill color indicate "at upper bound"
+            // Black font and darker fill color indicate "at upper bound".
             font_color = 'black';
             fill_color = (ub > 0 ? this.palette.at_pos_ub_fill :
                 (ub < 0 ? this.palette.at_neg_ub_fill :
                     this.palette.at_zero_ub_fill));
             at_bound = true;
           } else if (l - lb < VM.SIG_DIF_LIMIT) {
-            // Font and rim color indicate "at upper bound"
+            // Font and rim color indicate "at lower bound".
             font_color = 'black';
             fill_color = (lb > 0 ? this.palette.at_pos_lb_fill :
                 (lb < 0 ? this.palette.at_neg_lb_fill :
                     this.palette.at_zero_lb_fill));
             at_bound = true;
           } else {
-            // set "partial fill" flag if not at lower bound and UB < INF
+            // Set "partial fill" flag if not at lower bound and UB < INF.
             pf = ub < VM.PLUS_INFINITY;
             font_color = this.palette.within_bounds_font;
           }
         }
       } else if(ub - lb < VM.NEAR_ZERO) {
-        // Not solved but equal bounds => probably constants
+        // Not solved but equal bounds => probably constants.
         if(prod.isConstant && Math.abs(ub) > VM.NEAR_ZERO) {
-          // Non-zero constants have less saturated shades
+          // Non-zero constants have less saturated shades.
           fill_color = (ub < 0 ? this.palette.neg_constant :
               this.palette.pos_constant);  
         }
       } else if(l < VM.UNDEFINED) {
-        // Different bounds and initial level set => partial fill
+        // Different bounds and initial level set => partial fill.
         fill_color = this.palette.src_snk;
         pf = true;
         if(ub - l < VM.SIG_DIF_LIMIT || l - lb < VM.SIG_DIF_LIMIT) {
@@ -2418,8 +2420,8 @@ class Paper {
       let npfbg = 'white';
       if(fill_color === this.palette.above_upper_bound ||
           fill_color === this.palette.below_lower_bound ||
-          // NOTE: empty buffers (at level 0) should be entirely white
-          (at_bound && l > VM.ON_OFF_THRESHOLD)) {
+          // NOTE: Empty buffers should be entirely white.
+          (at_bound && l > lb + VM.ON_OFF_THRESHOLD)) {
         npfbg = fill_color;
         pf = false;
       }
@@ -2434,26 +2436,26 @@ class Paper {
           {fill: fill_color, stroke: stroke_color, 'stroke-width': stroke_width,
               'stroke-dasharray': sda, 'stroke-linecap': 'round',
               'rx': hh, 'ry': hh});
-      // NOTE: set fill color to darker shade for partial fill
+      // NOTE: Set fill color to darker shade for partial fill.
       fill_color = (!MODEL.solved ? this.palette.src_snk :
           (l > VM.NEAR_ZERO ? this.palette.above_zero_fill :
               (l < -VM.NEAR_ZERO ? this.palette.below_zero_fill :
                   this.palette.at_zero_fill)));
     }
-    // Add partial fill if appropriate
+    // Add partial fill if appropriate.
     if(pf && l > lb && l < VM.UNDEFINED) {
       // Calculate used part of range (1 = 100%)
       let part,
           range = ub - lb;
       if(l >= VM.PLUS_INFINITY) {
-        // Show exceptions and +INF as "overflow"
+        // Show exceptions and +INF as "overflow".
         part = 1;
         fill_color = this.palette.above_upper_bound;
       } else {
         part = (range > 0 ? (l - lb) / range : 1);
       }
       if(part > 0 && l >= lb) {
-        // Only fill the portion of used range with the fill color
+        // Only fill the portion of used range with the fill color.
         const rad = Math.asin(1 - 2*part);
         prod.shape.addPath(['m', x + hw - hh + (hh - 1.5) * Math.cos(rad),
             ',', y + (hh - 1.5) * Math.sin(rad),
@@ -2467,7 +2469,7 @@ class Paper {
     stroke_color = 'none';
     stroke_width = 0;
     // Sources have a triangle pointing up from the bottom
-    // (in outline if *implicit* source)
+    // (in outline if *implicit* source).
     if(prod.isSourceNode) {
       if(!prod.is_source) {
         fill_color = 'none';
@@ -2479,7 +2481,7 @@ class Paper {
           'stroke-width': stroke_width});
     }
     // Sinks have a triangle pointing down from the top
-    // (in outline if implicit sink)
+    // (in outline if implicit sink).
     if(prod.isSinkNode) {
       if(!prod.is_sink) {
         fill_color = 'none';
@@ -2491,7 +2493,7 @@ class Paper {
           'stroke-width': stroke_width});  
     }
     // Integer level is denoted by enclosing name in large [ and ]
-    // to denote "floor" as well as "ceiling"
+    // to denote "floor" as well as "ceiling".
     if(prod.integer_level) {
       const
           brh = prod.name_lines.split('\n').length * this.font_heights[8] + 4,

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

@@ -1574,7 +1574,7 @@ class LinnyRModel {
       const
           note = fc.notes[i],
           nbn = note.nearbyNode;
-      note.nearby_pos = (nbn ? {node: nbn, oldx: x, oldy: y} : null);
+      note.nearby_pos = (nbn ? {node: nbn, oldx: nbn.x, oldy: nbn.y} : null);
     }
     for(let i = 0; i < fc.processes.length; i++) {
       move = fc.processes[i].alignToGrid() || move;
@@ -5158,7 +5158,7 @@ class Note extends ObjectWithXYWH {
           // If attribute omitted, use default attribute of entity type.
           const attr = (ena.length > 1 ? ena[1].trim() : obj.defaultAttribute);
           let val = null;
-          // NOTE: for datasets, use the active modifier if no attribute.
+          // NOTE: For datasets, use the active modifier if no attribute.
           if(!attr && obj instanceof Dataset) {
             val = obj.activeModifierExpression;
           } else {
@@ -7894,13 +7894,11 @@ class Product extends Node {
   }
   
   get isConstant() {
-    // Return TRUE if this product is data, has no links to processes,
-    // is not an actor cash flow, and has set LB = UB
+    // Return TRUE if this product is data, is not an actor cash flow,
+    // has no ingoing links, has outgoing links ONLY to data objects,
+    // and has set LB = UB.
     if(!this.is_data || this.name.startsWith('$') ||
-        !this.allOutputsAreData) return false;
-    for(let i = 0; i < this.inputs.length; i++) {
-      if(this.inputs[i].from_node instanceof Process) return false;
-    }
+        this.inputs.length || !this.allOutputsAreData) return false;
     return (this.equal_bounds && this.lower_bound.defined);
   }
 
@@ -8847,11 +8845,30 @@ class Dataset {
   
   attributeValue(a) {
     // Return the computed result for attribute `a`.
-    // NOTE: Datasets have ONE attribute (their vector) denoted by the empty
-    // string; all other "attributes" should be modifier selectors, and
-    // their value should be obtained using attributeExpression (see below).
-    if(a === '') return this.vector;
-    return null;
+    // NOTE: Datasets have ONE attribute (their vector) denoted by the
+    // dot ".". All other "attributes" should be modifier selectors,
+    // and their value should be obtained using `attributeExpression(a)`.
+    // The empty string denotes "use default", which may have been set
+    // by the modeler, or may follow from the active combination of a
+    // running experiment.
+    if(a === '') {
+      const x = this.activeModifierExpression;
+      if(x instanceof Expression) {
+        x.compute(0);
+        // Ensure that for dynamic modifier expressions the vector is
+        // fully computed.
+        if(!x.isStatic) {
+          const nt = MODEL.end_period - MODEL.start_period + 1;
+          for(let t = 1; t <= nt; t++) x.result(t);
+        }
+        return x.vector;
+      }
+      // No modifier expression? Then return the dataset vector.
+      return this.vector;
+    }
+    if(a === '.') return this.vector;
+    // Fall-through: return the default value of this dataset.
+    return this.defaultValue;
   }
 
   attributeExpression(a) {
@@ -8881,7 +8898,7 @@ class Dataset {
       console.log('WARNING: Dataset "' + this.name +
           `" has no default selector "${this.default_selector}"`, this.modifiers);
     }
-    // Fall-through: return vector instead of expression.
+    // Fall-through: return the dataset vector.
     return this.vector;
   }
   
@@ -9290,23 +9307,11 @@ class ChartVariable {
       t_end = tsteps;
     } else {
       // Get the variable's own value (number, vector or expression)
-      // Special case: when an experiment is running, variables that
-      // depict a dataset with no explicit modifier must recompute the
-      // vector using the current experiment run combination.
-      if(MODEL.running_experiment &&
-          this.object instanceof Dataset && !this.attribute) {
-        // Check if dataset modifiers match the combination of selectors
-        // for the active run.
-        const mm = this.object.matchingModifiers(
-            MODEL.running_experiment.activeCombination);
-        // If so, use the first (the list should contain at most 1 selector)
-        // to select the modifier expression; otherwise, use the unmodified
-        // vector of the dataset
-        if(mm.length > 0) {
-          av = mm[0].expression;
-        } else {
-          av = this.object.vector;
-        }
+      if(this.object instanceof Dataset && !this.attribute) {
+        // Special case: Variables that depict a dataset with no explicit
+        // modifier selector must recompute the vector using the current
+        // experiment run combination or the default selector.
+        av = this.object.activeModifierExpression;
       } else if(this.object instanceof DatasetModifier) {
         av = this.object.expression;
       } else {
@@ -11075,7 +11080,8 @@ class ExperimentRun {
       bm.messages = VM.messages[i];
       this.block_messages.push(bm);
       this.warning_count += bm.warningCount;
-      this.solver_seconds += bm.solver_secs;
+      // NOTE: When set by the VM, `solver_secs` is a string.
+      this.solver_seconds += parseFloat(bm.solver_secs);
     }
   }
   

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

@@ -491,7 +491,9 @@ function matchingNumber(m, s) {
   // Returns an integer value if string `m` matches selector pattern `s`
   // (where asterisks match 0 or more characters, and question marks 1
   // character) and the matching parts jointly denote an integer.
-  let raw = s.replace(/\*/g, '(.*)').replace(/\?/g, '(.)'),
+  // NOTE: A "+" must be escaped, "*" and "?" must become groups.
+  let raw = s.replaceAll('+', '\+')
+          .replace(/\*/g, '(.*)').replace(/\?/g, '(.)'),
       match = m.match(new RegExp(`^${raw}$`)),
       n = '';
   if(match) {
@@ -601,6 +603,18 @@ function compareSelectors(s1, s2) {
   return 0;
 }
 
+function compareCombinations(c1, c2) {
+  // Compare two selector lists.
+  const n = Math.min(c1.length, c2.length);
+  for(let i = 0; i < n; i++) {
+    const cs = compareSelectors(c1[i], c2[i]);
+    if(cs) return cs;
+  }
+  if(c1.length > l) return 1;
+  if(c2.length > l) return -1;
+  return 0;
+}
+
 //
 // Functions that perform set-like operations on lists of string
 //

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

@@ -1394,9 +1394,13 @@ class ExpressionParser {
                   '-- number is:', this.context_number,
                   '\nTRACE: Expression:', obj.expression.text);
               // Use the context number as "selector" parameter of the VMI.
-              return [
-                  {d: obj.dataset, s: this.context_number, x: obj.expression},
-                  anchor1, offset1, anchor2, offset2];
+              const arg0 = (by_reference ?
+                  // If equation is "by reference", use VMI_push_entity
+                  // while passing the context number as extra parameter.
+                  {r: obj.dataset, a: obj.selector, cn: this.context_number} :
+                  // Otherwise, use VMI_push_dataset_modifier.
+                  {d: obj.dataset, s: this.context_number, x: obj.expression});
+              return [arg0, anchor1, offset1, anchor2, offset2];
             }
           }
         }
@@ -2452,7 +2456,7 @@ class VirtualMachine {
     if(n <= this.BAD_REF) return [true, '#REF?'];
     if(n <= this.ARRAY_INDEX) return [true, '#INDEX!'];
     if(n <= this.BAD_CALC) return [true, '#VALUE!'];
-    if(n <= this.DIV_ZERO) return [true, '#DIV0!'];
+    if(n <= this.DIV_ZERO) return [true, '#DIV/0!'];
     if(n <= this.CYCLIC) return [true, '#CYCLE!'];
     // Any other number less than or equal to 10^30 is considered as
     // minus infinity.
@@ -4767,7 +4771,7 @@ class VirtualMachine {
     // is calibrated for 1000 VMI instructions.
     this.tsl = Math.ceil(CONFIGURATION.progress_needle_interval *
         1000 / this.code.length);
-    if(true||abl > this.tsl * 5) {
+    if(abl > this.tsl * 5) {
       UI.setMessage('Constructing the Simplex tableau');
       UI.setProgressNeedle(0);
       this.show_progress = true;
@@ -5545,7 +5549,7 @@ Solver status = ${json.status}`);
       this.round_times.length = 0;
       this.solver_times[bnr - 1] = time;
       const ssecs = this.round_secs.reduce((a, b) => a + b, 0);
-      this.solver_secs[bnr - 1] = (ssecs ? VM.sig4Dig(ssecs) : '');
+      this.solver_secs[bnr - 1] = (ssecs ? VM.sig4Dig(ssecs) : '0');
       this.round_secs.length = 0;
       MONITOR.addProgressBlock(bnr, issue, time);
     }
@@ -6265,13 +6269,19 @@ function VMI_push_wildcard_entity(x, args) {
   } else {
     // Select the first entity in `ee` that matches the wildcard vector
     // index of the expression `x` being executed.
+    if(x.wildcard_vector_index === false && x.isWildcardExpression &&
+        MODEL.running_experiment) {
+      // If no wildcard vector index, try to infer it.
+      x.wildcard_vector_index = matchingNumberInList(
+          MODEL.running_experiment.activeCombination, x.attribute);
+    }
     nn = nn.replace('#', x.wildcard_vector_index);
     for(let i = 0; !obj && i < el.length; i++) {
       if(el[i].name === nn) obj = el[i];
     }
     // If no match, then this indicates a bad reference.
     if(!obj) {
-      console.log(`ERROR: no match for "${nn}" in eligible entity list`, el);
+      console.log(`ERROR: no match for "${nn}" in eligible entity list`, el, x);
       x.push(VM.BAD_REF);
       return;
     }
@@ -6281,7 +6291,8 @@ function VMI_push_wildcard_entity(x, args) {
   // called with the appropriate parameters.
   const attr = args[0].a || obj.defaultAttribute;
   if(args[0].br) {
-    VMI_push_entity(x, {r: obj, a: attr});
+    VMI_push_entity(x, [{r: obj, a: attr},
+        args[1], args[2], args[3], args[4]]);
     return;
   }
   // Otherwise, if the entity is a dataset modifier, this must be an
@@ -6824,7 +6835,7 @@ function VMI_mul(x) {
 
 function VMI_div(x) {
   // Pops the top number on the stack and divides the new top number
-  // by it. In case of division by zero, the top is replaced by #DIV0!
+  // by it. In case of division by zero, the top is replaced by #DIV/0!
   const d = x.pop();
   if(d !== false) {
     if(DEBUGGING) console.log('DIV (' + d.join(', ') + ')');
@@ -6838,7 +6849,7 @@ function VMI_div(x) {
 
 function VMI_mod(x) {
   // Pops the top number on the stack, divides the new top number by it
-  // (if non-zero, or it pushes error code #DIV0!), takes the fraction
+  // (if non-zero, or it pushes error code #DIV/0!), takes the fraction
   // part, and multiplies this with the divider; in other words, it
   // performs a "floating point MOD operation"
   const d = x.pop();
@@ -7159,39 +7170,41 @@ function VMI_jump(x, index) {
 }
 
 function VMI_jump_if_false(x, index) {
-  // Tests the top number A of the stack, and if A is FALSE (zero or
-  // VM.UNDEFINED) sets the program counter of the VM to `index` minus 1,
-  // as the counter is ALWAYS increased by 1 after calling a VMI function
+  // Test the top number A on the stack, and if A is FALSE (zero or
+  // VM.UNDEFINED) set the program counter of the VM to `index` minus 1,
+  // as the counter is ALWAYS increased by 1 after calling a VMI function.
   const r = x.top(true);
   if(DEBUGGING) console.log(`JUMP-IF-FALSE (${r}, ${index})`);
   if(r === 0 || r === VM.UNDEFINED || r === false) {
     // Only jump on FALSE, leaving the stack "as is", so that in case
-    // of no THEN the expression result equals the IF condition value
+    // of no THEN, the expression result equals the IF condition value.
     // NOTE: Also do this on a stack error (r === false)
     x.program_counter = index - 1;
   } else {
-    // Remove the value from the stack
+    // Remove the value from the stack.
     x.stack.pop();
   }
 }
 
 function VMI_pop_false(x) {
-  // Removes the top value from the stack, which should be 0 or
-  // VM.UNDEFINED (but this is not checked)
+  // Remove the top value from the stack, which should be 0 or
+  // VM.UNDEFINED (but this is not checked).
   const r = x.stack.pop();
   if(DEBUGGING) console.log(`POP-FALSE (${r})`);
 }
 
 function VMI_if_then(x) {
   // NO operation -- as of version 1.0.14, this function only serves as
-  // operator symbol, and its executions would indicate an error
-  console.log('WARNING: this IF-THEN instruction is obsolete!');
+  // placeholder in operator symbol arrays. The parser should no longer
+  // code this, so its execution would indicate an error.
+  console.log('WARNING: IF-THEN instruction is obsolete', x);
 }
 
 function VMI_if_else(x) {
   // NO operation -- as of version 1.0.14, this function only serves as
-  // operator symbol, and its executions would indicate an error
-  console.log('WARNING: this IF-THEN instruction is obsolete!');
+  // placeholder in operator symbol arrays. The parser should no longer
+  // code this, so its execution would indicate an error.
+  console.log('WARNING: IF-ELSE instruction is obsolete', x);
 }
 
 //
@@ -7424,7 +7437,7 @@ function VMI_set_bounds(args) {
   }
 }
 
-function VMI_clear_coefficients(empty) {
+function VMI_clear_coefficients() {
   if(DEBUGGING) console.log('clear_coefficients');
   VM.coefficients = {};
   VM.cash_in_coefficients = {};
@@ -7555,7 +7568,7 @@ function VMI_add_var_to_weighted_sum_coefficients(args) {
         VM.sig4Dig(w) + ' * ' + v.variableName + ' (t = ' + t + ')');
   }
   for(let i = 0; i <= d; i++) {
-    const r = v.result(t);
+    let r = v.result(t);
     if(args.length > 3) r /= (d + 1);
     if(k <= 0) {
       // See NOTE in VMI_add_const_to_coefficient instruction
@@ -7779,7 +7792,7 @@ function VMI_add_throughput_to_coefficient(args) {
   }
 }
 
-function VMI_set_objective(empty) {
+function VMI_set_objective() {
   // Copies the coefficients to the vector for the objective function
   if(DEBUGGING) console.log('set_objective');
   for(let i in VM.coefficients) if(Number(i)) {
@@ -7843,7 +7856,7 @@ function VMI_set_add_constraints_flag(args) {
       (VM.add_constraints_flag ? 'TRUE' : 'FALSE') + ')');
 }
 
-function VMI_toggle_add_constraints_flag(empty) {
+function VMI_toggle_add_constraints_flag() {
   // Toggles the VM's "add constraints" flag
   VM.add_constraints_flag = !VM.add_constraints_flag;
   if(DEBUGGING) console.log('toggle_add_constraints_flag (now ' +
@@ -7956,7 +7969,7 @@ function VMI_add_bound_line_constraint(args) {
     VM.coefficients[w[i]] = 1;
   }
   VM.rhs = 1;
-  VMI_add_constraint(VM.EQ)  
+  VMI_add_constraint(VM.EQ);
   // Add constraint (2):
   VMI_clear_coefficients();
   VM.coefficients[VM.offset + vix] = 1;
@@ -7964,7 +7977,7 @@ function VMI_add_bound_line_constraint(args) {
     VM.coefficients[w[i]] = -x[i];
   }
   // No need to set RHS as it is already reset to 0
-  VMI_add_constraint(VM.EQ)  
+  VMI_add_constraint(VM.EQ);
   // Add constraint (3):
   VMI_clear_coefficients();
   VM.coefficients[VM.offset + viy] = 1;
@@ -8105,23 +8118,24 @@ const
 // *** API section for custom operators ***
 //
 
-// Custom operators are typically used to implement computations on model results
-// that cannot be coded (efficiently) using standard expressions.
-// The first custom operator in this section demonstrates by example how custom
-// operators can be added.
+// Custom operators are typically used to implement computations on model
+// results that cannot be coded (efficiently) using standard expressions.
+// The first custom operator in this section demonstrates by example how
+// custom operators can be added.
 
 // Custom operators should preferably have a short alphanumeric string as
-// their identifying symbol. Custom operators are monadic and reducing, i.e.,
-// they must have a grouping as operand. The number of required arguments must
-// be checked at run time by the VM instruction for this operator.
+// their identifying symbol. Custom operators are monadic and reducing,
+// i.e., they must have a grouping as operand. The number of required
+// arguments must be checked at run time by the VM instruction for this
+// operator.
 
 // Each custom operator must have its own Virtual Machine instruction
   
 function VMI_profitable_units(x) {
-  // Replaces the argument list that should be at the top of the stack by the
-  // number of profitable units having a standard capacity (number), given the
-  // level (vector) of the process that represents multiple such units, the
-  // marginal cost (constant) and the market price (vector)
+  // Replace the argument list that should be at the top of the stack by
+  // the number of profitable units having a standard capacity (number),
+  // given the level (vector) of the process that represents multiple such
+  // units, the marginal cost (constant) and the market price (vector).
   const d = x.top();
   // Check whether the top stack element is a grouping of the correct size
   // that contains arguments of the correct type
@@ -8134,7 +8148,7 @@ function VMI_profitable_units(x) {
           d[3].entity.attributeExpression(d[3].attribute)) &&
       (d.length === 4 || (typeof d[4] === 'number' &&
           (d.length === 5 || typeof d[5] === 'number')))) {
-    // Valid parameters => get the data required for computation
+    // Valid parameters => get the data required for computation.
     const
         mup = d[0].entity, // the multi-unit process
         ub = mup.upper_bound.result(0), // NOTE: UB is assumed to be static 
@@ -8145,7 +8159,7 @@ function VMI_profitable_units(x) {
         pt = (d.length > 4 ? d[4] : 0), // the profit threshold (0 by default)
         // the time horizon (by default the length of the simulation period)
         nt = (d.length > 5 ? d[5] : MODEL.end_period - MODEL.start_period + 1); 
-    // Handle exceptional values of `uc` and `mc`
+    // Handle exceptional values of `uc` and `mc`.
     if(uc <= VM.BEYOND_MINUS_INFINITY || mc <= VM.BEYOND_MINUS_INFINITY) {
       x.retop(Math.min(uc, mc));
       return;
@@ -8155,16 +8169,16 @@ function VMI_profitable_units(x) {
       return;
     }
     
-    // NOTE: NPU is not time-dependent => result is stored in cache
-    // As expressions may contain several NPU operators, create a unique key
-    // based on its parameters
+    // NOTE: NPU is not time-dependent => result is stored in cache.
+    // As expressions may contain several NPU operators, create a unique
+    // key based on its parameters.
     const cache_key = ['npu', mup.code, ub, uc, mc, mpe.code, mpa, pt].join('_');
     if(x.cache[cache_key]) {
       x.retop(x.cache[cache_key]);
       return;
     }
     
-    // mp can be a single value, a vector, or an expression
+    // `mp` can be a single value, a vector, or an expression.
     let mp = mpe.attributeValue(mpa);
     if(mp === null) {
       mp = mpe.attributeExpression(mpa);
@@ -8179,8 +8193,8 @@ function VMI_profitable_units(x) {
         nu = Math.ceil(ub / uc), // Number of units
         r = [];
     if(mp && mp instanceof Expression) {
-      // NOTE: an expression may not have been (fully) computed yet
-      mp.compute();
+      // NOTE: An expression may not have been (fully) computed yet.
+      mp.compute(0);
       if(mp.isStatic) {
         mp = mp.result(0);
       } else {
@@ -8276,11 +8290,11 @@ function VMI_highest_cumulative_consecutive_deviation(x) {
         e = d[0].entity,
         a = d[0].attribute;
     let vector = e.attributeValue(a);
-    // NOTE: equations can also be passed by reference
+    // NOTE: Equations can also be passed by reference.
     if(e === MODEL.equations_dataset) {
       const x = e.modifiers[a].expression;
-      // NOTE: an expression may not have been (fully) computed yet
-      x.compute();
+      // NOTE: an expression may not have been (fully) computed yet.
+      x.compute(0);
       if(!x.isStatic) {
         const nt = MODEL.end_period - MODEL.start_period + 1;
         for(let t = 1; t <= nt; t++) x.result(t);
@@ -8390,6 +8404,181 @@ DYNAMIC_SYMBOLS.push('hccd');
 // Add to this list only if operation makes an expression level-based
 // LEVEL_BASED_CODES.push(VMI_...);
 
+function correlation_or_slope(x, c_or_s) {
+  // Replaces the argument list that should be at the top of the stack by
+  // either Spearman's correlation (r) or the slope (b) of the regression
+  // line y = a + bx for the two vectors X and Y that are passed as the
+  // two arguments of this function. Reason to combine these two statistics
+  // in one function is because the required operations are very similar.
+  // NOTES:
+  // (1) This function codes for two different operators and therefore
+  //     is a helper function. The two operators must each have their
+  //     own VM instruction -- see immediately after this function.
+  // (2) String `c_or_s` must be either 'correl' or 'slope'. 
+  // (3) The operands for this function must be vectors, not numbers,
+  //     so in the Linny-R expression they must be passed "by reference".
+  const
+      d = x.top(),
+      vmi = c_or_s;
+  // Check whether the top stack element is a grouping of two variables.
+  if(d instanceof Array && d.length === 2 &&
+      typeof d[0] === 'object' && d[0].hasOwnProperty('entity') &&
+      typeof d[1] === 'object' && d[1].hasOwnProperty('entity')) {
+    // Convert the two variables to vectors.
+    const vector = {x: {}, y: {}};
+    for(let k in vector) if(vector.hasOwnProperty(k)) {
+      const
+          i = ['x', 'y'].indexOf(k),
+          e = d[i].entity,
+          a = d[i].attribute;
+      vector[k].e = e;
+      vector[k].a = a;
+      vector[k].v = e.attributeValue(a);
+      vector[k].name = e.displayName + (a ? '|' + a : '');
+      vector[k].id = e.identifier;
+      // NOTE: Equations can also be passed by reference.
+      if(e === MODEL.equations_dataset) {
+        const eq = e.modifiers[UI.nameToID(a)].expression;
+        // Level-based equations require that the model has run.
+        if(eq.is_level_based && !MODEL.solved) {
+          x.retop(VM.NOT_COMPUTED);
+          return;
+        }
+        // NOTE: An equation may not have been (fully) computed yet.
+        eq.compute(0, x.wildcard_vector_index);
+        if(!eq.isStatic) {
+          const nt = MODEL.end_period - MODEL.start_period + 1;
+          for(let t = 1; t <= nt; t++) eq.result(t, x.wildcard_vector_index);
+        }
+        vector[k].v = eq.vector;
+      }
+    }
+    // If either operand is level-based, return "not computed" if the
+    // model has not been run yet.
+    if((VM.level_based_attr.indexOf(vector.x.a) >= 0 ||
+        VM.level_based_attr.indexOf(vector.y.a) >= 0) &&
+            !MODEL.solved) {
+      x.retop(VM.NOT_COMPUTED);
+      return;
+    }
+    if(Array.isArray(vector.x.v) && Array.isArray(vector.y.v)) {
+      // Valid parameters => compute the terms used in the formulas
+      // for correlation (r) and regression (slope and intercept)
+      // NOTE: Statistics are not time-dependent, so the result is stored
+      // in the expression's cache. As expressions may contain several
+      // correl and slope operators, create a unique key based on the
+      // operator name and its two operands.
+      const cache_key = [vmi, vector.x.id, vector.x.a,
+          vector.y.id, vector.y.a].join('_');
+      if(x.cache[cache_key]) {
+        x.retop(x.cache[cache_key]);
+        return;
+      }
+      if(true||DEBUGGING) {
+        console.log(`-- ${vmi}(${vector.x.name}, ${vector.y.name})`);
+      }
+      // NOTE: Vectors should have equal length.
+      const N = Math.min(vector.x.v.length, vector.y.v.length);
+      if(!N) {
+        // No data => result should be "division by zero"
+        x.retop(VM.DIV_ZERO);
+        return;
+      }
+      // Calculate dsq = N*variance for X and Y. 
+      for(let k in vector) if(vector.hasOwnProperty(k)) {
+        let sum = 0;
+        // NOTE: Ignore first element of vector (t=0).
+        for(let i = 1; i < N; i++) {
+          const v = vector[k].v[i];
+          // Handle exceptional values in vector.
+          if(v <= VM.BEYOND_MINUS_INFINITY || v >= VM.BEYOND_PLUS_INFINITY) {
+            x.retop(v);
+            return;
+          }
+          sum += v;
+        }
+        vector[k].sum = sum;
+        const mean = sum / N;
+        vector[k].mean = mean;
+        let dsq = 0;
+        // NOTE: Ignore first element of vector (t=0).
+        for(let i = 1; i < N; i++) {
+          const d = vector[k].v[i] - mean;
+          dsq += d * d;
+        }
+        vector[k].dsq = dsq;
+      }
+      // Divisor is sqrt(dsqX * dsqY). If zero, return #DIV/0
+      const divisor = Math.sqrt(vector.x.dsq * vector.y.dsq);
+      if(divisor < VM.NEAR_ZERO) {
+        x.retop(VM.DIV_ZERO);
+        return;
+      }
+      // Calculate N*covariance of X and Y.
+      let covar = 0;
+      // NOTE: Ignore first element of vector (t=0).
+      for(let i = 1; i < N; i++) {
+        covar += (vector.x.v[i] - vector.x.mean) * (vector.y.v[i] - vector.y.mean);
+      }
+      // Correlation = covarXY / sqrt(dsqX * dsqY), slope = covarXY / dsqX.
+      // NOTE: dsqX will be non-zero (or divisor would have been zero).
+      const result = covar / (vmi === 'correl' ? divisor : vector.x.dsq);
+      // Store the result in the expression's cache.
+      x.cache[cache_key] = result;
+      // Push the result onto the stack.
+      x.retop(result);
+      return;
+    }
+  }
+  // Fall-trough indicates error
+  if(DEBUGGING) console.log(vmi + ': invalid parameter(s)\n', d);
+  x.retop(VM.PARAMS);
+}
+
+// NOTE: Separate function for each operator: VMI_correl and VMI_slope.
+
+function VMI_correlation(x) {
+  correlation_or_slope(x, 'correl');
+}
+
+// Add the custom operator instruction to the global lists
+// NOTE: All custom operators are monadic (priority 9) and reducing
+OPERATORS.push('correl');
+MONADIC_OPERATORS.push('correl');
+ACTUAL_SYMBOLS.push('correl');
+OPERATOR_CODES.push(VMI_correlation);
+MONADIC_CODES.push(VMI_correlation);
+REDUCING_CODES.push(VMI_correlation);
+SYMBOL_CODES.push(VMI_correlation);
+PRIORITIES.push(9);
+// Add to this list only if operation makes an expression dynamic
+// DYNAMIC_SYMBOLS.push('...');
+// Add to this list only if operation makes an expression random
+// RANDOM_CODES.push(VMI_...);
+// Add to this list only if operation makes an expression level-based
+// LEVEL_BASED_CODES.push(VMI_...);
+
+function VMI_slope(x) {
+  correlation_or_slope(x, 'slope');
+}
+
+// Add the custom operator instruction to the global lists
+// NOTE: All custom operators are monadic (priority 9) and reducing
+OPERATORS.push('slope');
+MONADIC_OPERATORS.push('slope');
+ACTUAL_SYMBOLS.push('slope');
+OPERATOR_CODES.push(VMI_slope);
+MONADIC_CODES.push(VMI_slope);
+REDUCING_CODES.push(VMI_slope);
+SYMBOL_CODES.push(VMI_slope);
+PRIORITIES.push(9);
+// Add to this list only if operation makes an expression dynamic
+// DYNAMIC_SYMBOLS.push('...');
+// Add to this list only if operation makes an expression random
+// RANDOM_CODES.push(VMI_...);
+// Add to this list only if operation makes an expression level-based
+// LEVEL_BASED_CODES.push(VMI_...);
+
 /*** END of custom operator API section ***/
 
 ///////////////////////////////////////////////////////////////////////
@@ -8399,4 +8588,4 @@ if(NODE) module.exports = {
   Expression: Expression,
   ExpressionParser: ExpressionParser,
   VirtualMachine: VirtualMachine
-}
+};