linny-r 1.6.1 → 1.6.3

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

@@ -394,11 +394,12 @@ class Expression {
       vmi[0](this, vmi[1]);
       this.program_counter++;
     }
-    // Stack should now have length 1.
+    // Stack should now have length 1. If not, report error unless the
+    // length is due to some other error.
     if(this.stack.length > 1) {
-      v[t] = VM.OVERFLOW;
+      if(v[t] > VM.ERROR) v[t] = VM.OVERFLOW;
     } else if(this.stack.length < 1) {
-      v[t] = VM.UNDERFLOW;
+      if(v[t] > VM.ERROR) v[t] = VM.UNDERFLOW;
     } else {
       v[t] = this.stack.pop();
     }
@@ -1394,9 +1395,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 +2457,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.
@@ -2472,7 +2477,7 @@ class VirtualMachine {
     // Return number `n` formatted so as to show 2-3 significant digits
     // NOTE: as `n` should be a number, a warning sign will typically
     // indicate a bug in the software.
-    if(n === undefined) return '\u26A0'; // Warning sign
+    if(n === undefined || isNaN(n)) return '\u26A0'; // Warning sign
     const sv = this.specialValue(n);
     // If `n` has a special value, return its representation.
     if(sv[0]) return sv[1];
@@ -2968,10 +2973,10 @@ class VirtualMachine {
     if(vcnt == 0) return '(no variables)';
     let l = '';
     for(let i = 0; i < vcnt; i++) {
-      const obj = this.variables[i][1];
-      let v = 'X' + (i+1).toString().padStart(z, '0');
-      v += '     '.slice(v.length) + obj.displayName;
-      const p = (obj instanceof Process && obj.pace > 1 ? ' 1/' + obj.pace : '');
+      const
+          obj = this.variables[i][1],
+          v = 'X' + (i+1).toString().padStart(z, '0') + ' ' + obj.displayName,
+          p = (obj instanceof Process && obj.pace > 1 ? ' 1/' + obj.pace : '');
       l += v + ' [' + this.variables[i][0] + p + ']\n';
     }
     if(this.chunk_variables.length > 0) {
@@ -4767,7 +4772,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 +5550,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 +6270,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 +6292,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 +6836,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 +6850,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 +7171,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 +7438,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 +7569,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 +7793,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 +7857,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 +7970,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 +7978,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 +8119,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 +8149,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 +8160,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 +8170,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 +8194,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 +8291,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 +8405,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 +8589,4 @@ if(NODE) module.exports = {
   Expression: Expression,
   ExpressionParser: ExpressionParser,
   VirtualMachine: VirtualMachine
-}
+};