linny-r 2.0.5 → 2.0.7

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

@@ -10,7 +10,7 @@ the Linny-R project.
 */
 
 /*
-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
@@ -99,6 +99,7 @@ class LinnyRModel {
     this.align_to_grid = true;
     this.with_power_flow = false;
     this.infer_cost_prices = false;
+    this.ignore_negative_flows = false;
     this.report_results = false;
     this.show_block_arrows = true;
     this.last_zoom_factor = 1;
@@ -2585,6 +2586,15 @@ class LinnyRModel {
       const l = this.links[k];
       xl.push(l.relative_rate, l.flow_delay);
     }
+    for(let k in this.constraints) if(this.constraints.hasOwnProperty(k)) {
+      const c = this.constraints[k];
+      for(let i = 0; i < c.bound_lines.length; i++) {
+        const bl = c.bound_lines[i];
+        for(let j = 0; j < bl.selectors.length; j++) {
+          xl.push(bl.selectors[j].expression);
+        }
+      }
+    }
     return xl;
   }
 
@@ -2736,6 +2746,7 @@ class LinnyRModel {
       this.align_to_grid = nodeParameterValue(node, 'align-to-grid') === '1';
       this.with_power_flow = nodeParameterValue(node, 'power-flow') === '1';
       this.infer_cost_prices = nodeParameterValue(node, 'cost-prices') === '1';
+      this.ignore_negative_flows = nodeParameterValue(node, 'negative-flows') === '1';
       this.report_results = nodeParameterValue(node, 'report-results') === '1';
       this.show_block_arrows = nodeParameterValue(node, 'block-arrows') === '1';
       // NOTE: Diagnosis option should default to TRUE unless *set* to FALSE.
@@ -3106,6 +3117,7 @@ class LinnyRModel {
     if(this.align_to_grid) p += ' align-to-grid="1"';
     if(this.with_power_flow) p += ' power-flow="1"';
     if(this.infer_cost_prices) p += ' cost-prices="1"';
+    if(this.ignore_negative_flows) p += ' negative-flows="1"';
     if(this.report_results) p += ' report-results="1"';
     if(this.show_block_arrows) p += ' block-arrows="1"';
     if(this.show_notices) p += ' show-notices="1"';
@@ -3522,6 +3534,15 @@ class LinnyRModel {
       }
       this.cleanVector(l.actual_flow, p * l.relative_rate.result(0));
     }
+    for(let k in this.constraints) if(this.constraints.hasOwnProperty(k)) {
+      const c = this.constraints[k];
+      for(let i = 0; i < c.bound_lines.length; i++) {
+        const bl = c.bound_lines[i];
+        for(let j = 0; j < bl.selectors.length; j++) {
+          bl.selectors[j].expression.reset(0);
+        }
+      }
+    }
     for(obj in this.datasets) if(this.datasets.hasOwnProperty(obj)) {
       const ds = this.datasets[obj];
       ds.resetExpressions();
@@ -5780,7 +5801,7 @@ class NodeBox extends ObjectWithXYWH {
   }
   
   resize() {
-    // Resizes this node; returns TRUE iff size has changed.
+    // Resize this node; returns TRUE iff size has changed.
     // Therefore, keep track of original width and height.
     const
         ow = this.width,
@@ -5793,7 +5814,7 @@ class NodeBox extends ObjectWithXYWH {
       w = Math.max(w, UI.textSize(`[${this.scale_unit}]`).width);
     }
     this.frame_width = w + 7;
-    // Add 17 pixels height for actor name
+    // Add 17 pixels height for actor name.
     this.height = Math.max(50, this.bbox.height + 17);
     if(this instanceof Process) {
       this.width = Math.max(90, this.frame_width + 20);
@@ -5801,11 +5822,11 @@ class NodeBox extends ObjectWithXYWH {
     } else if(this instanceof Cluster) {
       this.width = Math.max(
           CONFIGURATION.min_cluster_size, this.frame_width + 20);
-      // Clusters have a square shape
+      // Clusters have a square shape.
       this.height = Math.max(this.width, this.height); 
     } else {
       this.height += 8;
-      // Reserve some extra space for UB/LB if defined
+      // Reserve some extra space for UB/LB if defined.
       if(this.lower_bound.defined || this.upper_bound.defined) {
         this.frame_width += 16;
       }
@@ -8261,20 +8282,20 @@ class Product extends Node {
     // By default, processes have the letter p, products the letter q.
     this.TEX_id = 'p';
     // For products, the default bounds are [0, 0], and modeler-defined bounds
-    // typically are equal
+    // typically are equal.
     this.equal_bounds = true;
-    // In addition to LB, UB and IL, products has 1 input attribute: P
+    // In addition to LB, UB and IL, products has 1 input attribute: P.
     this.price = new Expression(this, 'P', '');
-    // Products have a highest cost price, and may have a stock price (if storage)
+    // Products have a highest cost price, and may have a stock price (if storage).
     this.highest_cost_price = [];
     this.stock_price = [];
     // Stock level changing from 0 to positive counts as "start up", while
-    // changing from positive to 0 counts as a "shut-down"
-    // NOTE: being relatively rare, start_ups and shut_downs are not vectors,
-    // but store the numbers of the time steps in which they occurred
+    // changing from positive to 0 counts as a "shut-down".
+    // NOTE: Being relatively rare, start_ups and shut_downs are not vectors,
+    // but store the numbers of the time steps in which they occurred.
     this.start_ups = [];
     this.shut_downs = [];
-    // Modeler may set explicit properties
+    // Modeler may set explicit properties.
     this.is_source = false;
     this.is_sink = false;
     this.is_buffer = false;
@@ -8629,13 +8650,13 @@ class Product extends Node {
   }
 
   get defaultAttribute() {
-    // Products have their level as default attribute 
+    // Products have their level as default attribute.
     return 'L';
   }
 
   attributeValue(a) {
-    // Returns the computed result for attribute `a`
-    // (for products, this is always a vector except IL)
+    // Return the computed result for attribute `a`.
+    // NOTE: For products, this is always a vector except IL.
     if(a === 'L') return this.level;
     if(a === 'CP') return this.cost_price;
     if(a === 'HCP') return this.highest_cost_price;
@@ -8643,7 +8664,7 @@ class Product extends Node {
   }
 
   attributeExpression(a) {
-    // Products have four expression attributes
+    // Products have four expression attributes.
     if(a === 'LB') return this.lower_bound;
     if(a === 'UB') {
       return (this.equal_bounds ? this.lower_bound : this.upper_bound);
@@ -8727,7 +8748,7 @@ class Product extends Node {
   }
 
   copyPropertiesFrom(p) {
-    // Set properties to be identical to those of product `p`
+    // Set properties to be identical to those of product `p`.
     this.x = p.x;
     this.y = p.y;
     this.comments = p.comments;
@@ -8744,11 +8765,11 @@ class Product extends Node {
     this.initial_level.text = p.initial_level.text;
     this.integer_level = p.integer_level;
     this.TEX_id = p.TEX_id;
-    // NOTE: do not copy the `no_links` property, nor the import/export status
+    // NOTE: Do not copy the `no_links` property, nor the import/export status.
   }
 
   differences(p) {
-    // Return "dictionary" of differences, or NULL if none
+    // Return "dictionary" of differences, or NULL if none.
     const d = differences(this, p, UI.MC.PRODUCT_PROPS);
     if(Object.keys(d).length > 0) return d;
     return null;
@@ -12678,6 +12699,10 @@ class BoundLine {
         VM.constraint_codes[this.type] + '] bound line #' +
         this.constraint.bound_lines.indexOf(this);
   }
+  
+  get name() {
+    return this.displayName;
+  }
 
   get copy() {
     // Return a "clone" of this bound line.
@@ -12969,11 +12994,12 @@ class BoundLine {
   }
   
   get needsNoSOS() {
-    // Return 1 if boundline is NOT of type <= and line segments have an
-    // increasing slope, -1 if boundline is NOT of type >= and line segments
+    // Return 1 if boundline is of type >= and line segments have an
+    // increasing slope, -1 if boundline is of type <= and line segments
     // have a decreasing slope, and otherwise 0 (FALSE). If non-zero (TRUE),
     // the constraint can be implemented without the SOS2 constraint that
     // only two consecutive SOS variables may be non-zero.
+    if(this.type === VM.EQ) return 0;
     if(this.type !== VM.LE) {
       let slope = 0,
           pp = this.points[0];

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

@@ -9,7 +9,7 @@ This JavaScript file (linny-r-utils.js) defines a variety of "helper" functions
 that are used in other Linny-R modules.
 */
 /*
-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
@@ -74,16 +74,16 @@ function safeStrToFloat(str, val=0) {
 }
 
 function safeStrToInt(str, val=0) {
-  // Returns numeric value of integer string, IGNORING decimals after
+  // Return numeric value of integer string, IGNORING decimals after
   // point or comma.
-  // NOTE: returns default value `val` if `str` is empty, null or undefined
+  // NOTE: Return default value `val` if `str` is empty, null or undefined.
   const n = (str ? parseInt(str) : val);
   return (isNaN(n) ? val : n);
 }
 
 function rangeToList(str, max=0) {
-  // Parses ranges "n-m/i" into a list of integers
-  // Returns FALSE if range is not valid according to the convention below
+  // Parse ranges "n-m/i" into a list of integers
+  // Return FALSE if range is not valid according to the convention below
   // The part "/i" is optional and denotes the increment; by default, i = 1.
   // The returned list will contain all integers starting at n and up to
   // at most (!) m, with increments of i, so [n, n+i, n+2i, ...]
@@ -112,6 +112,33 @@ function rangeToList(str, max=0) {
   return list;
 }
 
+function listToRange(list) {
+  // Return a string that represents the given list of integers as a series
+  // of subranges, e.g., [0,1,2,3,5,6,9,11] results in "0-3, 5-6, 9, 11".
+  const
+      n = list.length,
+      subs = [];
+  if(!n) return '';
+  let i = 0,
+      from = list[0],
+      to = from;
+  while(i < n) {
+    i++;
+    if(list[i] === to + 1) {
+      to++;
+    } else {
+      if(from === to) {
+        subs.push(from);
+      } else {
+        subs.push(`${from}-${to}`);
+      }
+      from = list[i];
+      to = from;
+    }
+  }
+  return subs.join(', ');
+}
+
 function dateToString(d) {
   // Returns date-time `d` in UTC format, accounting for time zone
   const offset = d.getTimezoneOffset();
@@ -1098,6 +1125,7 @@ if(NODE) module.exports = {
   safeStrToFloat: safeStrToFloat,
   safeStrToInt: safeStrToInt,
   rangeToList: rangeToList,
+  listToRange: listToRange,
   dateToString: dateToString,
   msecToTime: msecToTime,
   compactClockTime: compactClockTime,

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,21 @@ 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 ||
+    // 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 +1853,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 +1868,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 +2124,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 +2474,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 +2589,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 +2617,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 +3214,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 +4348,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 +4630,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));
@@ -4763,14 +4773,16 @@ class VirtualMachine {
         a.cash_out[b] = this.checkForInfinity(
             x[a.cash_out_var_index + j] * this.cash_scalar);
         a.cash_flow[b] = a.cash_in[b] - a.cash_out[b];
-        // Count occurrences of a negative cash flow (threshold -0.5 cent).
-        if(b <= this.nr_of_time_steps && a.cash_in[b] < -0.005) {
-          this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
-              a.displayName + ' cash IN = ' + a.cash_in[b].toPrecision(2));
-        }
-        if(b <= this.nr_of_time_steps && a.cash_out[b] < -0.005) {
-          this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
-              a.displayName + ' cash OUT = ' + a.cash_out[b].toPrecision(2));
+        if(!MODEL.ignore_negative_flows) {
+          // Count occurrences of a negative cash flow (threshold -0.5 cent).
+          if(b <= this.nr_of_time_steps && a.cash_in[b] < -0.005) {
+            this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
+                a.displayName + ' cash IN = ' + a.cash_in[b].toPrecision(2));
+          }
+          if(b <= this.nr_of_time_steps && a.cash_out[b] < -0.005) {
+            this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
+                a.displayName + ' cash OUT = ' + a.cash_out[b].toPrecision(2));
+          }
         }
         // Advance column offset in tableau by the # cols per time step.
         j += this.cols;
@@ -4785,8 +4797,7 @@ class VirtualMachine {
           p = MODEL.processes[o],
           has_OO = (p.on_off_var_index >= 0),
           has_SU = (p.start_up_var_index >= 0),
-          has_SD = (p.shut_down_var_index >= 0),
-          grid = p.grid;
+          has_SD = (p.shut_down_var_index >= 0);
       // Clear all start-ups and shut-downs at t >= bb.
       if(has_SU) p.resetStartUps(bb);
       if(has_SD) p.resetShutDowns(bb);
@@ -5193,11 +5204,11 @@ class VirtualMachine {
       MODEL.products_with_negative_delays = {};
       b = bb;
       for(let i = 0; i < cbl; i++) {
-        // NOTE: Issues with cost price calculation beyond simulation
-        // period need not be reported.
         if(b <= this.nr_of_time_steps && !MODEL.calculateCostPrices(b)) {
-          this.logMessage(block, `${this.WARNING}(t=${b}) ` +
-              'Invalid cost prices due to negative flow(s)');
+        // NOTE: Issues with cost price calculation beyond simulation
+        // period need not be reported unless model is set to ignore this.
+          if(!MODEL.ignore_negative_flows) this.logMessage(block,
+              `${this.WARNING}(t=${b}) Invalid cost prices due to negative flow(s)`);
         }
         // Move on to the next time step of the block.
         b++;
@@ -5695,7 +5706,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) {
@@ -6159,7 +6169,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();
   }
   
@@ -6311,7 +6323,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:'];
@@ -6340,6 +6352,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;
@@ -7580,6 +7613,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();
@@ -8216,6 +8351,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
@@ -9269,7 +9411,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 = ['!=', '<>', '>=', '<='],
@@ -9301,13 +9443,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
@@ -9315,7 +9457,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
@@ -9323,7 +9465,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);