linny-r 2.0.6 → 2.0.8

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

@@ -12,7 +12,7 @@ executed by the VM, construct the Simplex tableau that can be sent to the
 MILP solver.
 */
 /*
-Copyright (c) 2017-2024 Delft University of Technology
+Copyright (c) 2017-2025 Delft University of Technology
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -444,17 +444,27 @@ class Expression {
     // expression).
     if(t < 0 || this.isStatic) t = 0;
     if(t >= v.length) return VM.UNDEFINED;
-    // 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 ||
+    // Check for recursive calls.
+    if(v[t] === VM.COMPUTING) {
+      console.log('Already computing expression for', this.variableName);
+      console.log(this.text);
+      return VM.CYCLIC;
+    }
+    // NOTES:
+    // (1) When VM is setting up a tableau, values computed for the
+    //     look-ahead period must be recomputed.
+    // (2) Always recompute value for sensitivity analysis parameter, as
+    //     otherwise the vector value will be scaled cumulatively.
+    const sap = (this === MODEL.active_sensitivity_parameter);
+    if(sap || 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
-    // analysis, the result is multiplied by 1 + delta %
-    if(this === MODEL.active_sensitivity_parameter) {
-      // NOTE: do NOT scale exceptional values
+    // NOTE: When this expression is the "active" parameter for sensitivity
+    // analysis, the result is multiplied by 1 + delta %.
+    if(sap) {
+      // NOTE: Do NOT scale exceptional values.
       if(v[t] > VM.MINUS_INFINITY && v[t] < VM.PLUS_INFINITY) {
         v[t] *= (1 + MODEL.sensitivity_delta * 0.01);
       }
@@ -1849,14 +1859,14 @@ class ExpressionParser {
       if(this.then_stack.length < 1) {
         this.error = 'Unexpected :';
       } else {
-        // Similar to above: when a : operator is "coded", the ELSE part
+        // Similar to above: When a : operator is "coded", the ELSE part
         // has been coded, so the end of the code array is the target for
-        // the most recently added JUMP
+        // the most recently added JUMP.
         this.code[this.then_stack.pop()][1] = this.code.length;
       }
     } else {
       // All other operations require VM instructions that operate on the
-      // expression stack
+      // expression stack.
       this.code.push([op, null]);
       if(op === VMI_concat) {
         this.concatenating = true;
@@ -1864,8 +1874,8 @@ class ExpressionParser {
         const randcode = RANDOM_CODES.indexOf(op) >= 0;
         if(REDUCING_CODES.indexOf(op) >= 0) {
           if(randcode && !this.concatenating) {
-            // NOTE: probability distributions MUST have a parameter list but
-            // MIN and MAX will also accept a single argument
+            // NOTE: Probability distributions MUST have a parameter list but
+            // MIN and MAX will also accept a single argument.
             console.log('OPERATOR:', op);
             this.error = 'Missing parameter list';
           }
@@ -2120,6 +2130,8 @@ class VirtualMachine {
     this.numeric_issue = '';
     // Warnings are stored in a list to permit browsing through them.
     this.issue_list = [];
+    // Bound issues (UB < LB) are recorded to permit compact warnings.
+    this.bound_issues = {};
     // The call stack tracks evaluation of "nested" expression variables.
     this.call_stack = [];
     this.block_count = 0;
@@ -2468,6 +2480,8 @@ class VirtualMachine {
     // block).
     this.error_count = 0;
     this.block_issues = 0;
+    // Clear bound issue dictionary.
+    this.bound_issues = {};
     // Clear issue list with warnings and hide issue panel.
     this.issue_list.length = 0;
     this.issue_index = -1;
@@ -2581,6 +2595,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(typeof n === 'string') n = parseFloat(n);
     if(n === undefined || isNaN(n)) return '\u26A0'; // Warning sign
     const sv = this.specialValue(n);
     // If `n` has a special value, return its representation.
@@ -2608,6 +2623,7 @@ class VirtualMachine {
     // 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.
+    if(typeof n === 'string') n = parseFloat(n);
     if(n === undefined || isNaN(n)) return '\u26A0';
     const sv = this.specialValue(n); 
     // If `n` has a special value, return its representation.
@@ -3204,8 +3220,8 @@ class VirtualMachine {
   
   setBoundConstraints(p) {
     // Set LB and UB constraints for product `p`.
-    // NOTE: This method affects the VM coefficient vector, so save it
-    // (if needed) before calling this method.
+    // NOTE: This method affects the VM coefficient vector, so this vector
+    // should be saved (using a VM instruction) if it is needed later.
     const
         vi = p.level_var_index,
         lesvi = p.stock_LE_slack_var_index,
@@ -4338,7 +4354,7 @@ class VirtualMachine {
                     ' will compromise computation of its binary variables';
                 UI.warn(msg);
                 this.logMessage(this.block_count,
-                    'WARNING: ' + msg.replace(/<\/?strong>/g, '"'));
+                    this.WARNING + msg.replace(/<\/?strong>/g, '"'));
               }
             }
             if(hub !== ub) {
@@ -4620,8 +4636,8 @@ class VirtualMachine {
             high_rate) + 1);
     if(this.slack_penalty > VM.MAX_SLACK_PENALTY) {
       this.slack_penalty = VM.MAX_SLACK_PENALTY;
-      this.logMessage(this.block_count,
-        'WARNING: Max. slack penalty reached; try to scale down your model coefficients');
+      this.logMessage(this.block_count, this.WARNING +
+          'Max. slack penalty reached; try to scale down your model coefficients');
     }
     const m = Math.max(
         Math.abs(this.low_coefficient), Math.abs(this.high_coefficient));
@@ -5696,7 +5712,6 @@ class VirtualMachine {
             return ` +${c} ${v}`; // Prefix coefficient with +
             // NOTE: This may return  +0 X001.
           };
-
     this.numeric_issue = '';
     // First add the objective (always MAXimize).
     if(cplex) {
@@ -6160,7 +6175,9 @@ class VirtualMachine {
   }
 
   stopSolving() {
+    // Wrap-up after solving is completed or aborted.    
     this.stopTimer();
+    // Stop rotating the Linny-R icon, and update buttons.
     UI.stopSolving();
   }
   
@@ -6312,7 +6329,7 @@ Solver status = ${json.status}`);
     }
     // If negative delays require "fixating" variables for some number
     // of time steps, this must be logged in the monitor.
-    const keys = Object.keys(this.variables_to_fixate);
+    let keys = Object.keys(this.variables_to_fixate);
     if(keys.length) {
       const msg = ['NOTE: Due to negative link delays, levels for ' +
             pluralS(keys.length, 'variable') + ' are pre-set:'];
@@ -6341,6 +6358,27 @@ Solver status = ${json.status}`);
       }
       this.logMessage(this.block_count, msg.join('\n'));
     }
+    // Convert bound issues to warnings in the Monitor.
+    keys = Object.keys(this.bound_issues).sort();
+    const n = keys.length;
+    if(n) {
+      let vlist = '',
+          first = 1e20;
+      for(let i = 0; i < n; i++) {
+        const
+            k = keys[i],
+            bit = this.bound_issues[k];
+        vlist += `\n   - ${k} (t=${listToRange(bit)})`;
+        first = Math.min(first, bit[0]);
+      }
+      const msg = `Lower bound exceeds upper bound for ${n} processes`;
+      this.logMessage(this.block_count,
+          `${this.WARNING}(t=${first}) ${msg}:${vlist}`);
+      UI.warn(msg + ' - check Monitor for details');
+      // Clear bound issue dictionary, so next block starts anew.
+      this.bound_issues = {};
+    }
+    // Create the input file for the solver.
     this.logMessage(this.block_count,
         'Creating model for block #' + this.blockWithRound);
     this.cbl = CONFIGURATION.progress_needle_interval * 200;
@@ -7581,6 +7619,108 @@ function VMI_ge(x) {
   }
 }
 
+function VMI_at(x) {
+  // Pop the top number on the stack, and use its integer part as index i
+  // to replace the new top element (which must be a dataset or a grouping)
+  // by its i-th element.
+  let d = x.pop();
+  if(d !== false) {
+    if(DEBUGGING) console.log('AT (' + d.join(', ') + ')');
+    let a,
+        from = false,
+        to = false,
+        step = 1,
+        group = false,
+        period = false,
+        range = [],
+        ok = true;
+    // Check whether the first argument (d[0]) is indexable.
+    if(d[0] instanceof Array) {
+      a = d[0];
+      group = true;
+    } else if(d[0].entity instanceof Dataset) {
+      a = d[0].entity.vector;
+      period = d[0].periodic;
+    } else {
+      x.retop(VM.ARRAY_INDEX);
+      return;
+    }
+    // Check whether the second argument (d[1]) is a number or a pair.
+    if(d[1] instanceof Array) {
+      if(d[1].length > 3 || typeof d[1][0] !== 'number') {
+        ok = false;
+      } else if(d[1].length === 3) {
+        // Optional third index argument is range index increment.
+        if(typeof d[1][2] === 'number') {
+          step = Math.floor(d[1][2]);
+          // Ignore increment if it truncates to zero.
+          if(!step) step = 1;
+          // Get the range end.
+          if(typeof d[1][1] === 'number') {
+            to = Math.floor(d[1][1]);
+          } else {
+            ok = false;
+          }
+        } else {
+          ok = false;
+        }
+      } else if(d[1].length === 2) {
+        // Optional second argument is range index end.
+        if(typeof d[1][1] === 'number') {
+          to = Math.floor(d[1][1]);
+        } else {
+          ok = false;
+        }
+      }
+      if(ok) {
+        from = Math.floor(d[1][0]);
+        // Groupings are 0-based arrays but indexed as 1-based.
+        if(group) {
+          from--;
+          to--;
+        }
+        // Check whether from, to and step are feasible.
+        if(to !== false) {
+          if(to <= from && step < 0) {
+            for(let i = from; i >= to; i += step) range.push(i);
+          } else if(to >= from && step > 0) {
+            for(let i = from; i <= to; i += step) range.push(i);
+          } else {
+            ok = false;
+          }
+        }
+      }
+    }
+    if(ok && !range.length && typeof d[1] === 'number') {
+      range = [Math.floor(d[1]) - (group ? 1 : 0)];
+    } else if(!range.length) {
+      ok = false;
+    }
+    if(!ok) {
+      x.retop(VM.ARRAY_INDEX);
+      return;
+    }
+    const
+        n = range.length,
+        r = [];
+    for(let i = 0; i < n; i++) {
+      const index = range[i];
+      if(index < 0) {
+        r.push(VM.UNDEFINED);
+      } else if(period) {
+        r.push(a[index % a.length]);
+      } else {
+        r.push(a[index]);
+      }
+    }
+    if(n === 1) {
+      x.retop(r[0]);
+    } else {
+      x.retop(r);
+    }
+  }
+}
+
 function VMI_add(x) {
   // Pop the top number on the stack, and add it to the new top number.
   const d = x.pop();
@@ -8217,6 +8357,13 @@ function VMI_set_bounds(args) {
     console.log(['set_bounds [', k, '] ', vbl.displayName, '[',
       VM.variables[vi - 1][0],'] t = ', VM.t, ' LB = ', VM.sig4Dig(l),
       ', UB = ', VM.sig4Dig(u), fixed].join(''), l, u, inf_val);
+  } else if(u < l) {
+    // Warn that "impossible" bounds would have been set...
+    const vk = vbl.displayName;
+    if(!VM.bound_issues[vk]) VM.bound_issues[vk] = [];
+    VM.bound_issues[vk].push(VM.t);
+    // ... and set LB to UB, so that lowest value is bounding.
+    l = u;
   }
   // NOTE: Since the VM vectors for lower bounds and upper bounds are
   // initialized with default values (0 for LB, +INF for UB), the bounds
@@ -9270,7 +9417,7 @@ function VMI_add_available_capacity(link) {
 const
   // Valid symbols in expressions
   PARENTHESES = '()',
-  OPERATOR_CHARS = ';?:+-*/%=!<>^|',
+  OPERATOR_CHARS = ';?:+-*/%=!<>^|@',
   // Opening bracket, space and single quote indicate a separation
   SEPARATOR_CHARS = PARENTHESES + OPERATOR_CHARS + "[ '",
   COMPOUND_OPERATORS = ['!=', '<>', '>=', '<='],
@@ -9302,13 +9449,13 @@ const
       VMI_weibull, VMI_npv],
   DYADIC_OPERATORS = [
       ';', '?', ':', 'or', 'and',
-      '=', '<>', '!=',
-      '>', '<', '>=', '<=', '+', '-', '*', '/',
+      '=', '<>', '!=', '>', '<', '>=', '<=',
+      '@', '+', '-', '*', '/',
       '%', '^', 'log', '|'],
   DYADIC_CODES = [
       VMI_concat, VMI_if_then, VMI_if_else, VMI_or, VMI_and,
       VMI_eq, VMI_ne, VMI_ne, VMI_gt, VMI_lt, VMI_ge, VMI_le,
-      VMI_add, VMI_sub, VMI_mul, VMI_div, VMI_mod,
+      VMI_at, VMI_add, VMI_sub, VMI_mul, VMI_div, VMI_mod,
       VMI_power, VMI_log, VMI_replace_undefined],
 
   // Compiler checks for random codes as they make an expression dynamic
@@ -9316,7 +9463,7 @@ const
       VMI_triangular, VMI_weibull],
   
   // Compiler checks for reducing codes to unset its "concatenating" flag
-  REDUCING_CODES = [VMI_min, VMI_max, VMI_binomial, VMI_normal,
+  REDUCING_CODES = [VMI_at, VMI_min, VMI_max, VMI_binomial, VMI_normal,
       VMI_triangular, VMI_weibull, VMI_npv],
   
   // Custom operators may make an expression level-based
@@ -9324,7 +9471,7 @@ const
   
   OPERATORS = DYADIC_OPERATORS.concat(MONADIC_OPERATORS), 
   OPERATOR_CODES = DYADIC_CODES.concat(MONADIC_CODES),
-  PRIORITIES = [1, 2, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 10,
+  PRIORITIES = [1, 2, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5.5, 6, 6, 7, 7, 7, 8, 8, 10,
       9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9],
   ACTUAL_SYMBOLS = CONSTANT_SYMBOLS.concat(OPERATORS),
   SYMBOL_CODES = CONSTANT_CODES.concat(OPERATOR_CODES);