linny-r 1.7.0 → 1.7.2

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

@@ -2044,29 +2044,29 @@ class ExpressionParser {
 // CLASS VirtualMachine
 class VirtualMachine {
   constructor() {
-    // Set user name to default as configured in file `linny-r-config.js`
-    // This will be an empty string for local host servers
+    // Set user name to default as configured in file `linny-r-config.js`.
+    // This will be an empty string for local host servers.
     this.solver_user = SOLVER.user_id;
-    // NOTE: if not empty, then authentication is needed
+    // NOTE: If not empty, then authentication is needed.
     if(this.solver_user) {
-      // If URL contains ?u=, set user name to the passed parameter
+      // If URL contains ?u=, set user name to the passed parameter.
       let url = decodeURI(window.location.href);
-      // NOTE: trim cache buster suffix that may have been added
+      // NOTE: Trim cache buster suffix that may have been added.
       if(url.indexOf('?x=') > 0) url = url.split('?x=')[0].trim();
       if(url.indexOf('?u=') > 0) {
         this.solver_user = url.split('?u=')[1].trim();
       }
     }
-    // NOTE: if not null, the callback function is called when the VM has
-    // finished a run; this is used by the console version of Linny-R
+    // NOTE: If not null, the callback function is called when the VM has
+    // finished a run. This is used by the console version of Linny-R.
     this.callback = null;
-    // Solver limits may be set in file `linny-r-config.js` (0 => unlimited)
+    // Solver limits may be set in file `linny-r-config.js` (0 => unlimited).
     this.max_solver_time = SOLVER.max_solver_time;
     this.max_blocks = SOLVER.max_nr_of_blocks;
     this.max_tableau_size = SOLVER.max_tableau_size;
-    // Standard variables: array of tuples [type, object]
+    // Standard variables: array of tuples [type, object].
     this.variables = [];
-    // Indices for special types
+    // Indices for special variable types.
     this.int_var_indices = [];
     this.bin_var_indices = [];
     this.sec_var_indices = [];
@@ -2075,35 +2075,35 @@ class VirtualMachine {
     this.fixed_var_indices = [];
     // Chunk variables: also an array of tuples [type, object], but
     // so far, type is always HI (highest increment); object can be
-    // a process or a product
+    // a process or a product.
     this.chunk_variables = [];
-    // Array for VM instructions
+    // Array for VM instructions.
     this.code = [];
-    // The Simplex tableau: matrix, rhs and ct will have same length
+    // The Simplex tableau: matrix, rhs and ct will have same length.
     this.matrix = [];
     this.right_hand_side = [];
     this.constraint_types = [];
-    // String to hold lines of (solver-dependent) model equations
+    // String to hold lines of (solver-dependent) model equations.
     this.lines = '';
-    // String specifying a numeric issue (empty if none)
+    // String specifying a numeric issue (empty if none).
     this.numeric_issue = '';
-    // Warnings are stored in a list to permit browsing through them
+    // Warnings are stored in a list to permit browsing through them.
     this.issue_list = [];
-    // The call stack tracks evaluation of "nested" expression variables
+    // The call stack tracks evaluation of "nested" expression variables.
     this.call_stack = [];
     this.block_count = 0;
-    // Sequence of round numbers (set by default or as experiment parameter)
+    // Sequence of round numbers (set by default or as experiment parameter).
     this.round_sequence = '';
-    // NOTE: current round is index in round sequence
+    // NOTE: Current round is index in round sequence.
     this.current_round = 0;
-    // Add arrays for solver results per block
+    // Add arrays for solver results per block.
     this.round_times = [];
     this.round_secs = [];
     this.solver_times = [];
     this.solver_secs = [];
     this.messages = [];
     this.equations = [];
-    // Default texts to display for (still) empty results
+    // Default texts to display for (still) empty results.
     this.no_messages = '(no messages)';
     this.no_variables = '(no variables)';
     this.no_equations = '(select block in progress bar)';
@@ -2122,26 +2122,29 @@ class VirtualMachine {
     this.BEYOND_MINUS_INFINITY = -1e+35;
     this.SOLVER_PLUS_INFINITY = 1e+30;
     this.SOLVER_MINUS_INFINITY = -1e+30;
-    // NOTE: below the "near zero" limit, a number is considered zero
-    // (this is to timely detect division-by-zero errors)
+    // NOTE: Below the "near zero" limit, a number is considered zero
+    // (this is to timely detect division-by-zero errors).
     this.NEAR_ZERO = 1e-10;
     // Use a specific constant smaller than near-zero to denote "no cost"
-    // to differentiate "no cost" form cost prices that really are 0
+    // to differentiate "no cost" form cost prices that really are 0.
     this.NO_COST = 0.987654321e-10;
 
-    // NOTE: allow for an accuracy margin: stocks may differ 0.1%  from their
-    // target without displaying them in red or blue to signal shortage or surplus
+    // NOTE: Allow for an accuracy margin: stocks may differ 0.1%  from
+    // their target without displaying them in red or blue to signal
+    // shortage or surplus.
     this.SIG_DIF_LIMIT = 0.001;
     this.SIG_DIF_FROM_ZERO = 1e-6;
-    // On/off threshold is used to differentiate between level = 0 and still "ON"
-    // (will be displayed as +0)
+    // ON/OFF threshold is used to differentiate between level = 0 and
+    // still "ON" (will be displayed as +0).
     this.ON_OFF_THRESHOLD = 1.5e-4;
-    // Limit for upper bounds beyond which binaries cannot be computed correctly
+    // Limit for upper bounds beyond which binaries cannot be computed
+    // correctly. Modeler is warned when this occurs (typically when
+    // ON/OFF variables are needed for a process having infinite bounds.
     this.MEGA_UPPER_BOUND = 1e6;
-    // Limit slack penalty to one order of magnitude below +INF
+    // Limit slack penalty to one order of magnitude below +INF.
     this.MAX_SLACK_PENALTY = 0.1 * this.PLUS_INFINITY;
   
-    // VM constants for specifying the type of cash flow operation
+    // VM constants for specifying the type of cash flow operation.
     this.CONSUME = 0;
     this.PRODUCE = 1;
     this.ONE_C = 2;
@@ -2149,16 +2152,16 @@ class VirtualMachine {
     this.THREE_X = 4;
     this.SPIN_RES = 5;
     this.PEAK_INC = 6;
-    // Array of corrsponding strings for more readable debugging information
+    // Array of corrsponding strings for more readable debugging information.
     this.CF_CONSTANTS = ['CONSUME', 'PRODUCE', 'ONE_C', 'TWO_X',
         'THREE_X', 'SPIN_RES'];
     
-    // Constraint cost price transfer direction
+    // Constraint cost price transfer direction.
     this.SOC_X_Y = 1;
     this.SOC_Y_X = -1;
 
-    // Link multiplier type numbers
-    // NOTE: do *NOT* change existing values, as this will cause legacy issues!!
+    // Link multiplier type numbers.
+    // NOTE: Do *NOT* change existing values, as this will cause legacy issues!
     this.LM_LEVEL = 0; // No symbol
     this.LM_THROUGHPUT = 1; // Symbol: two parallel right-pointing arrows
     this.LM_INCREASE = 2; // Symbol: Delta
@@ -2176,11 +2179,11 @@ class VirtualMachine {
     this.LM_SYMBOLS = ['', '\u21C9', '\u0394', '\u03A3', '\u03BC', '\u25B2',
         '+', '0', '\u2934', '\u2732', '\u25BC', '\u2A39'];
     
-    // VM max. expression stack size
+    // VM max. expression stack size.
     this.MAX_STACK = 200;
 
-    // Base penalty of 10 is high relative to the (scaled) coefficients of the
-    // cash flows in the objective function (typically +/- 1)
+    // Base penalty of 10 is high relative to the (scaled) coefficients of
+    // the cash flows in the objective function (typically +/- 1).
     this.BASE_PENALTY = 10;
     // Peak variable penalty is added to make solver choose the *smallest*
     // value that is greater than or equal to X[t] for all t as "peak value".
@@ -2189,17 +2192,17 @@ class VirtualMachine {
     // solution (highest total cash flow).
     this.PEAK_VAR_PENALTY = 0.1;
   
-    // NOTE: the VM uses numbers >> +INF to denote special computation results
+    // NOTE: The VM uses numbers >> +INF to denote special computation results.
     this.EXCEPTION = 1e+36; // to test for any exceptional value
     this.UNDEFINED = 1e+37; // to denote "unspecified by the user"
     this.NOT_COMPUTED = 1e+38; // initial value for VM variables (to distinguish from UNDEFINED)
     this.COMPUTING = 1e+39; // used by the VM to implement lazy evaluation
   
     // NOTES:
-    // (1) computation errors are signalled by NEGATIVE values << -10^35
-    // (2) JavaScript exponents can go up to +/- 308 (IEEE 754 standard)
-    // (3) when adding/modifying these values, ALSO update the VM methods for
-    //     representing these values as human-readable strings!
+    // (1) Computation errors are signalled by NEGATIVE values << -10^35.
+    // (2) JavaScript exponents can go up to +/- 308 (IEEE 754 standard).
+    // (3) when adding/modifying these values, ALSO update the VM methods
+    //     for representing these values as human-readable strings!
     
     this.ERROR = -1e+40; // Any lower value indicates a computation error
     this.CYCLIC = -1e+41;
@@ -2218,12 +2221,12 @@ class VirtualMachine {
       this.BAD_REF, this.UNDERFLOW, this.OVERFLOW, this.INVALID, this.PARAMS,
       this.UNKNOWN_ERROR, this.UNDEFINED, this.NOT_COMPUTED, this.COMPUTING];
     
-    // Prefix for warning messages that are logged in the monitor
+    // Prefix for warning messages that are logged in the monitor.
     this.WARNING = '-- Warning: ';
 
-    // Solver constants indicating constraint type
-    // NOTE: these correspond to the codes used by LP_solve; when generating
-    // MPS files, other constants are used
+    // Solver constants indicating constraint type.
+    // NOTE: These correspond to the codes used in the LP format. When
+    // generating MPS files, other constants are used.
     this.FR = 0;
     this.LE = 1;
     this.GE = 2;
@@ -2239,18 +2242,18 @@ class VirtualMachine {
       'hour': 1, 'minute': 1/60, 'second': 1/3600
     };
     // More or less standard time unit abbreviations.
-    // NOTE: minute is abbreviated to `m` to remain consistent with the constants
-    // that can be used in expressions. There, `min` already denotes the "minimum"
-    // operator.
+    // NOTE: Minute is abbreviated to `m` to remain consistent with the
+    // constants that can be used in expressions. There, `min` already
+    // denotes the "minimum" operator.
     this.time_unit_shorthand = {
       'year': 'yr', 'week': 'wk', 'day': 'd',
       'hour': 'h', 'minute': 'm', 'second': 's'
     };
     // Number of rounds limited to 31 because JavaScript performs bitwise
-    // operations on 32 bit integers, and the sign bit may be troublesome
+    // operations on 32 bit integers, and the sign bit may be troublesome.
     this.max_rounds = 31;
     this.round_letters = '?abcdefghijklmnopqrstuvwxyzABCDE';
-    // Standard 1-letter codes for Linny-R entities
+    // Standard 1-letter codes for Linny-R entities.
     this.entity_names = {
       A: 'actor',
       B: 'constraint',
@@ -2262,7 +2265,7 @@ class VirtualMachine {
       Q: 'product'
     };
     this.entity_letters = 'ABCDELPQ';
-    // Standard attributes of Linny-R entities
+    // Standard attributes of Linny-R entities.
     this.attribute_names = {
       'LB':  'lower bound',
       'UB':  'upper bound',
@@ -2282,18 +2285,18 @@ class VirtualMachine {
       'SOC': 'share of cost',
       'A':   'active'
     };
-    // NOTE: defaults are level (L), link flow (F), cluster cash flow (CF),
-    // actor cash flow (CF); dataset value (no attribute)
-    // NOTE: exogenous properties first, then the computed properties
+    // NOTE: Defaults are level (L), link flow (F), cluster cash flow (CF),
+    // actor cash flow (CF); dataset value (no attribute).
+    // NOTE: Exogenous properties first, then the computed properties.
     this.process_attr = ['LB', 'UB', 'IL', 'LCF', 'L', 'CI', 'CO', 'CF', 'CP'];
     this.product_attr = ['LB', 'UB', 'IL', 'P', 'L', 'CP', 'HCP'];
     this.cluster_attr = ['CI', 'CO', 'CF'];
     this.link_attr = ['R', 'D', 'SOC', 'F'];
     this.constraint_attr = ['SOC', 'A'];
     this.actor_attr = ['W', 'CI', 'CO', 'CF'];
-    // Only expression attributes can be used for sensitivity analysis
+    // Only expression attributes can be used for sensitivity analysis.
     this.expression_attr = ['LB', 'UB', 'IL', 'LCF', 'P', 'R', 'D', 'W'];
-    // Attributes per entity type letter
+    // Attributes per entity type letter.
     this.attribute_codes = {
       A: this.actor_attr,
       B: this.constraint_attr,
@@ -2314,18 +2317,19 @@ class VirtualMachine {
         this.entity_attribute_names[el].push(ac[j]);
       }
     }
-    // Level-based attributes are computed only AFTER optimization
+    // Level-based attributes are computed only AFTER optimization.
     this.level_based_attr = ['L', 'CP',  'HCP', 'CF', 'CI', 'CO', 'F', 'A'];
     this.object_types = ['Process', 'Product', 'Cluster', 'Link', 'Constraint',
         'Actor', 'Dataset', 'Equation'];
     this.type_attributes = [this.process_attr, this.product_attr,
         this.cluster_attr, this.link_attr, this.constraint_attr,
         this.actor_attr, [], []];
-    // Statistics that can be calculated for sets of variables 
+    // Statistics that can be calculated for sets of variables.
     this.statistic_operators =
       ['MAX', 'MEAN', 'MIN', 'N', 'SD', 'SUM', 'VAR',
        'MAXNZ', 'MEANNZ', 'MINNZ', 'NNZ', 'SDNZ', 'SUMNZ', 'VARNZ'];
-    // Statistics that can be calculated for outcomes and experiment run results
+    // Statistics that can be calculated for outcomes and experiment run
+    // results.
     this.outcome_statistics =
       ['LAST', 'MAX', 'MEAN', 'MIN', 'N', 'NZ', 'SD', 'SUM', 'VAR'];
     this.solver_names = {
@@ -2370,8 +2374,9 @@ class VirtualMachine {
     // (1) MODEL.runLength = simulation period + look-ahead, so that
     //     should not be used to compute the number of blocks.
     // (2) For each block, a chunk (block + lookahead) is optimized.
+    this.nr_of_time_steps = MODEL.end_period - MODEL.start_period + 1;
     this.nr_of_blocks = Math.ceil(
-        (MODEL.end_period - MODEL.start_period + 1) / MODEL.block_length);
+        this.nr_of_time_steps / MODEL.block_length);
 
     // EXAMPLE: Simulation period of 55 time steps, block length of 10
     // time steps and no look-ahead => 6 chunks, and chunk length = block
@@ -2390,8 +2395,13 @@ class VirtualMachine {
     this.issue_list.length = 0;
     this.issue_index = -1;
     UI.updateIssuePanel();
-    // NOTE: Special tracking of potential solver license errors.
+    // Special tracking of potential solver license errors.
     this.license_expired = 0;
+    // Variables that will be decided by the solver again in the next
+    // block must be "fixated" when, due to a negative link delay, they
+    // would have consequences for the previous block (and these will be
+    // ignored).
+    this.variables_to_fixate = {};
     // Reset solver result arrays.
     this.round_times.length = 0;
     this.solver_times.length = 0;
@@ -2951,7 +2961,6 @@ class VirtualMachine {
       return obj.la_peak_inc[c];
     }
     const prior_level = obj.actualLevel(t);
-//console.log('HERE obj prilev t', obj.displayName, prior_level, t, obj.level);
     if(type === 'OO') return prior_level > 0 ? 1 : 0;
     if(type === 'IZ') return prior_level === 0 ? 1 : 0;
     // Start-up at time t entails that t is in the list of start-up
@@ -3136,7 +3145,7 @@ class VirtualMachine {
 
     // FIRST: define indices for all variables (index = Simplex tableau column number)
 
-    // Each actor has a variable to compute its cash in and its cash out
+    // Each actor has a variable to compute its cash in and its cash out.
     const actor_keys = Object.keys(MODEL.actors).sort();
     for(i = 0; i < actor_keys.length; i++) {
       const a = MODEL.actors[actor_keys[i]];
@@ -3243,9 +3252,9 @@ class VirtualMachine {
     // NOTE: Chunk variables of node `p` have LB = 0 and UB = UB of `p`.
     // This is effectuated by the VM "set bounds" instructions at run time.
 
-    // NOTE: Under normal assumptions (all processes having LB >= 0), bounds on
-    // actor cash flow variables need NOT be set because cash IN and cash OUT
-    // will then always be >= 0 (solver's default bounds).
+    // NOTE: Under normal assumptions (all processes having LB >= 0), bounds
+    // on actor cash flow variables need NOT be set because cash IN and
+    // cash OUT will then always be >= 0 (solver's default bounds).
     // However, Linny-R does not prohibit negative bounds on processes, nor
     // negative rates on links. To be consistently permissive, cash IN and
     // cash OUT of all actors are both allowed to become negative.
@@ -3271,18 +3280,18 @@ class VirtualMachine {
       if(!MODEL.ignored_entities[k]) {
         p = MODEL.processes[k];
         lbx = p.lower_bound;
-        // NOTE: if UB = LB, set UB to LB only if LB is defined,
+        // NOTE: If UB = LB, set UB to LB only if LB is defined,
         // because LB expressions default to -INF while UB expressions
-        // default to + INF
+        // default to +INF.
         ubx = (p.equal_bounds && lbx.defined ? lbx : p.upper_bound);
         if(lbx.isStatic) lbx = lbx.result(0);
         if(ubx.isStatic) ubx = ubx.result(0);
-        // NOTE: pass TRUE as fourth parameter to indicate that +INF
+        // NOTE: Pass TRUE as fourth parameter to indicate that +INF
         // and -INF can be coded as the infinity values used by the
         // solver, rather than the Linny-R values used to detect
-        // unbounded problems
+        // unbounded problems.
         this.code.push([VMI_set_bounds, [p.level_var_index, lbx, ubx, true]]);
-        // Add level variable index to "fixed" list for specified rounds
+        // Add level variable index to "fixed" list for specified rounds.
         const rf = p.actor.round_flags;
         if(rf != 0) {
           // Note: 32-bit integer `b` is used for bit-wise AND
@@ -3333,9 +3342,9 @@ class VirtualMachine {
 
     // NOTE: Each process generates cash flow proportional to its production
     //       level if it produces and/or consumes a product having a price.
-    //       Cash flow is negative (cash OUT) if a product is consumed AND has
-    //       price > 0, but positive (cash IN) if a product is produced and has
-    //       price < 0. Likewise for the other two cases.
+    //       Cash flow is negative (cash OUT) if a product is consumed AND
+    //       has price > 0, but positive (cash IN) if a product is produced
+    //       and has price < 0. Likewise for the other two cases.
     //       To calculate the coefficient for the process variable, the
     //       multiplier rates of the links in and out must be calculated (at
     //       run time when dynamic expressions) such that they will add to the
@@ -3357,21 +3366,24 @@ class VirtualMachine {
     //       on this vector. If expressions for process properties are
     //       static, more efficient VM instructions are used.
 
-    // Initially assume "no cash flows for any actor to be considered"
+    // Initially assume "no cash flows for any actor to be considered".
+    // This flag will be set to FALSE when some actor cash flow constraint
+    // has a non-zero coefficient.
     this.no_cash_flows = true;
     
-    // Iterate over all actors to add the cash flow computation constraints
+    // Iterate over all actors to add the cash flow computation constraints.
     for(let ai = 0; ai < actor_keys.length; ai++) {
       const a = MODEL.actors[actor_keys[ai]];
-      this.code.push([VMI_clear_coefficients, null]);
+      // NOTE: No need for VMI_clear_coefficients because the cash flow
+      // coefficients operate on two special "registers" of the VM.
       for(i = 0; i < process_keys.length; i++) {
         k = process_keys[i];
         if(!MODEL.ignored_entities[k]) {
           const p = MODEL.processes[k];
-          // Only consider processes owned by this actor
+          // Only consider processes owned by this actor.
           if(p.actor === a) {
-            // Iterate over links IN, but only consider consumed products having
-            // a market price
+            // Iterate over links IN, but only consider consumed products
+            // having a market price.
             for(j = 0; j < p.inputs.length; j++) {
               l = p.inputs[j];
               if(!MODEL.ignored_entities[l.identifier] &&
@@ -3379,18 +3391,17 @@ class VirtualMachine {
                 if(l.from_node.price.isStatic && l.relative_rate.isStatic) {
                   k = l.from_node.price.result(0) * l.relative_rate.result(0);
                   // NOTE: VMI_update_cash_coefficient has at least 4 arguments:
-                  // flow (CONSUME or PRODUCE), type (specifies the number and type
-                  // of arguments), the level_var_index of the process, and the
-                  // delay.
+                  // flow (CONSUME or PRODUCE), type (specifies the number and
+                  // type of arguments), the level_var_index of the process,
+                  // and the delay.
+                  // NOTE: Input links cannot have delay, so then delay = 0.
                   if(Math.abs(k) > VM.NEAR_ZERO) {
-                    // Consumption rate & price are static: pass one constant
-                    // NOTE: input links cannot have delay, so delay = 0
+                    // Consumption rate & price are static: pass one constant.
                     this.code.push([VMI_update_cash_coefficient,
                       [VM.CONSUME, VM.ONE_C, p.level_var_index, 0, k]]);
                   }
                 } else {
-                  // No further optimization: assume two dynamic expressions
-                  // NOTE: input links cannot have delay, so delay = 0
+                  // No further optimization: assume two dynamic expressions.
                   this.code.push([VMI_update_cash_coefficient,
                     [VM.CONSUME, VM.TWO_X, p.level_var_index, 0,
                      l.from_node.price, l.relative_rate]]);
@@ -3399,15 +3410,16 @@ class VirtualMachine {
             } // END of FOR ALL input links
             
             // Iterate over links OUT, but only consider produced products
-            // having a (non-zero) market price
+            // having a (non-zero) market price.
             for(j = 0; j < p.outputs.length; j++) {
               l = p.outputs[j];
               const tnpx = l.to_node.price;
               if(!MODEL.ignored_entities[l.identifier] && tnpx.defined &&
                   !(tnpx.isStatic && Math.abs(tnpx.result(0)) < VM.NEAR_ZERO)) {
-                // By default, use the process level as multiplier
+                // By default, use the process level as multiplier.
                 vi = p.level_var_index;
-                // For "binary data links", use the correct binary variable instead
+                // For "binary data links", use the correct binary variable
+                // instead of the level.
                 if(l.multiplier === VM.LM_STARTUP) {
                   vi = p.start_up_var_index;
                 } else if(l.multiplier === VM.LM_FIRST_COMMIT) {
@@ -3428,57 +3440,63 @@ class VirtualMachine {
                   // times the rate of `l`.
                   for(k = 0; k < l.from_node.inputs.length; j++) {
                     ll = l.from_node.inputs[k];
-                    // NOTE: no attempt for efficiency -- assume that
-                    // price and both rates are dynamic
+                    // NOTE: No attempt for efficiency -- assume that
+                    // price and both rates are dynamic.
                     this.code.push([VMI_update_cash_coefficient, [
                         VM.PRODUCE, VM.THREE_X, vi, l.flow_delay, tnpx,
                         l.relative_rate, ll.relative_rate]]);
                   }
                 } else if(l.multiplier === VM.LM_SPINNING_RESERVE) {
-                  // "spinning reserve" equals UB - level if level > 0, or 0
-                  // The cash flow then equals ON/OFF * UB * price * rate MINUS
-                  // level * price * rate, hence a special instruction type
-                  // NOTE: only the ON/OFF variable determines whether there will
-                  // be any cash flow, hence it is passed as the primary variable,
-                  // and the process level as the secondary variable
+                  // "spinning reserve" equals UB - level if level > 0,
+                  // and otherwise 0. The cash flow then equals
+                  // ON/OFF * UB * price * rate MINUS level * price * rate,
+                  // hence a special instruction type.
+                  // NOTE: Only the ON/OFF variable determines whether
+                  // there will be any cash flow, hence it is passed as
+                  // the primary variable, and the process level as the
+                  // secondary variable.
                   this.code.push([VMI_update_cash_coefficient, [
-                      VM.PRODUCE, VM.SPIN_RES, p.on_off_var_index, l.flow_delay, vi,
-                      l.from_node.upper_bound, tnpx, l.relative_rate]]);
+                      VM.PRODUCE, VM.SPIN_RES, p.on_off_var_index,
+                      l.flow_delay, vi, l.from_node.upper_bound, tnpx,
+                      l.relative_rate]]);
                 } else if(l.multiplier === VM.LM_PEAK_INC) {
-                  // NOTE: "peak increase" may be > 0 only in the first time step
-                  // of the block being optimized, and in the first step of the
-                  // look-ahead period (if peak rises in that period), and will
-                  // be 0 in all other time steps; the VM instruction handles this
+                  // NOTE: "peak increase" may be > 0 only in the first
+                  // time step of the block being optimized, and in the
+                  // first step of the look-ahead period (if peak rises
+                  // in that period), and will be 0 in all other time steps.
+                  // The VM instruction handles this.
                   // NOTE: Delay is always 0 for this link flow.
                   this.code.push([VMI_update_cash_coefficient, [
                       VM.PRODUCE, VM.PEAK_INC, p.peak_inc_var_index, 0,
                       tnpx, l.relative_rate]]);
                 } else if(tnpx.isStatic && l.relative_rate.isStatic) {
-                  // If link rate and product price are static, only add the variable
-                  // if rate*price is non-zero (and th en use the static VM instruction)
+                  // If link rate and product price are static, only add
+                  // the variable if rate*price is non-zero (and then pass
+                  // the constant rate*price to the VM instruction.
                   k = tnpx.result(0) * l.relative_rate.result(0);
                   if(Math.abs(k) > VM.NEAR_ZERO) {
-                    // Production rate & price are static: pass one constant
+                    // Production rate & price are static: pass one constant.
                     this.code.push([VMI_update_cash_coefficient,
                         [VM.PRODUCE, VM.ONE_C, vi, l.flow_delay, k]]);
                     // When multiplier is Delta, subtract level in previous t
-                    // (so add 1 to flow delay, and consume, rather than produce)
+                    // (so add 1 to flow delay, and consume, rather than
+                    // produce).
                     if(l.multiplier === VM.LM_INCREASE) {
                       this.code.push([VMI_update_cash_coefficient,
-                          // NOTE: 6th argument = 1 indicates "delay + 1"
+                          // NOTE: 6th argument = 1 indicates "delay + 1".
                           [VM.CONSUME, VM.ONE_C, vi, l.flow_delay, k, 1]]);
                     }
                   }
                 } else {
-                  // Production rate or price are dynamic: pass two expressions
+                  // Production rate or price are dynamic: pass two expressions.
                   this.code.push([VMI_update_cash_coefficient, [
                       VM.PRODUCE, VM.TWO_X, vi, l.flow_delay,
                       tnpx, l.relative_rate]]);
-                  // When multiplier is Delta, consume level in previous t
+                  // When multiplier is Delta, consume level in previous t.
                   if(l.multiplier === VM.LM_INCREASE) {
                     this.code.push([VMI_update_cash_coefficient, [
                         VM.CONSUME, VM.TWO_X, vi, l.flow_delay,
-                        // NOTE: now 7th argument indicates "delay + 1"
+                        // NOTE: Now 7th argument indicates "delay + 1".
                         tnpx, l.relative_rate, 1]]);
                   }
                 }
@@ -3487,33 +3505,26 @@ class VirtualMachine {
           } // END of FOR ALL output links
         } // END of IF process not ignored
       } // END of FOR ALL processes
-      
-      // NOTE: if the last VM instruction still is "clear coefficients",
-      //       this means that (so far) no actor cash flows were detected
-      if(this.no_cash_flows) {
-        this.no_cash_flows =
-            this.code[this.code.length-1][0] === VMI_clear_coefficients;
-      }
-      
-      // ALWAYS add the two cash flow constraints for this actor, as both cash
-      // flow variables must be computed (will be 0 if no cash flows)
-      this.code.push(
-          [VMI_copy_cash_coefficients, VM.PRODUCE],
-          [VMI_add_const_to_coefficient, [a.cash_in_var_index, 1]],
-          [VMI_add_constraint, VM.EQ],
-          [VMI_copy_cash_coefficients, VM.CONSUME],
-          [VMI_add_const_to_coefficient, [a.cash_out_var_index, 1]],
-          [VMI_add_constraint, VM.EQ]
-      );
-      
+
+      // Check whether any VMI_update_cash_coefficient instructions have
+      // been added. If so, the objective function will maximze weighted
+      // sum of actor cash flows, otherwise minimize sum of process levels.
+      this.no_cash_flows = this.no_cash_flows &&
+          this.code[this.code.length - 1][0] !== VMI_update_cash_coefficient;
+
+      // ALWAYS add the two cash flow constraints for this actor, as both
+      // cash flow variables must be computed (will be 0 if no cash flows).
+      this.code.push([VMI_add_cash_constraints,
+          [a.cash_in_var_index, a.cash_out_var_index]]);
+
     } // END of FOR loop iterating over all actors
     
-    // NEXT: define the coefficients for the objective function
+    // NEXT: Define the coefficients for the objective function.
     this.code.push([VMI_clear_coefficients, null]);
 
-    // NOTE: if, after all actors -- this includes (no actor) -- have been
-    // considered, no cash flows have been detected, the solver should aim for
-    // minimal effort, i.e., lowest weighted sum of process levels
+    // NOTE: If, after all actors -- this includes (no actor) -- have been
+    // considered, no cash flows have been detected, the solver should aim
+    // for minimal effort, i.e., lowest weighted sum of process levels.
     if(this.no_cash_flows) {
       for(i = 0; i < process_keys.length; i++) {
         k = process_keys[i];
@@ -4285,8 +4296,9 @@ class VirtualMachine {
     // largest cash flow coefficient (in absolute value) within the
     // current block so that cash flows cannot easily "overrule" the
     // slack penalties in the objective function.
-    // NOTE: No scaling needed if model features no cash flows.
-    if(this.no_cash_flows) return;
+    // NOTE: No scaling needed if model features no cash flows, or if
+    // cash scalar equals 1.
+    if(this.no_cash_flows || this.cash_scalar === 1) return;
     this.logMessage(this.block_count,
         'Cash flows scaled by 1/' + this.cash_scalar);
     // Use reciprocal as multiplier to scale the constraint coefficients.
@@ -4307,7 +4319,7 @@ class VirtualMachine {
       }
     }
   }
-
+  
   checkForInfinity(n) {
     // Return floating point number `n`, or +INF or -INF if the absolute
     // value of `n` is relatively (!) close to the VM infinity constants
@@ -4333,8 +4345,6 @@ class VirtualMachine {
     let bb = (block - 1) * MODEL.block_length + 1,
         abl = this.chunk_length,
         cbl = this.actualBlockLength(block);
-    // For the last block, crop the actual block length so it does not
-    // extend beyond the simulation period (these results should be ignored).
     // If no results computed, preserve those already computed for the
     // pervious chunk as "look-ahead".
     if(err && block > 1 && MODEL.look_ahead > 0) {
@@ -4345,7 +4355,9 @@ class VirtualMachine {
           'No results from solver -- retained results of ' +
               pluralS(MODEL.look_ahead, 'look-ahead time step'));
     }
-    if(cbl <= 0) {
+    // For the last block, crop the actual block length so it does not
+    // extend beyond the simulation period (these results should be ignored).
+    if(cbl < 0) {
       this.logMessage(block, 'Results of last optimization could be discarded');
       abl = 0;
     } else if(cbl < abl) {
@@ -4365,41 +4377,41 @@ class VirtualMachine {
         ncv_msg + ' is not a multiple of # columns', this.cols);
     // Assume no warnings or errors.
     this.error_count = 0;
-    // Set cash flows for all actors
-    // NOTE: all cash IN and cash OUT values should normally be non-negative,
+    // Set cash flows for all actors.
+    // NOTE: All cash IN and cash OUT values should normally be non-negative,
     // but since Linny-R permits negative lower bounds on processes, and also
     // negative link rates, cash flows may become negative. If that occurs,
     // the modeler should be warned.
     for(let o in MODEL.actors) if(MODEL.actors.hasOwnProperty(o)) {
       const a = MODEL.actors[o];
-      // NOTE: `b` is the index to be used for the vectors
+      // NOTE: `b` is the index to be used for the vectors.
       let b = bb;
-      // Iterate over all time steps in this block
-      // NOTE: -1 because indices start at 1, but list is zero-based
+      // Iterate over all time steps in this block.
+      // NOTE: -1 because indices start at 1, but list is zero-based.
       let j = -1; 
       for(let i = 0; i < abl; i++) {
-        // NOTE: cash coefficients computed by the solver must be scaled back
+        // NOTE: Cash coefficients computed by the solver must be scaled back.
         a.cash_in[b] = this.checkForInfinity(
             x[a.cash_in_var_index + j] * this.cash_scalar);
         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(a.cash_in[b] < -0.005) {
+        // 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(a.cash_out[b] < -0.005) {
+        if(b <= this.nr_of_time_steps && a.cash_out[b] < -0.005) {
           this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
               a.displayName + ' cash IN = ' + a.cash_out[b].toPrecision(2));
         }
-        // Advance column offset in tableau by the # cols per time step
+        // Advance column offset in tableau by the # cols per time step.
         j += this.cols;
-        // Advance to the next time step in this block
+        // Advance to the next time step in this block.
         b++;
       }
     }
-    // Set production levels and start-up moments for all processes
+    // Set production levels and start-up moments for all processes.
     for(let o in MODEL.processes) if(MODEL.processes.hasOwnProperty(o) &&
         !MODEL.ignored_entities[o]) {
       const
@@ -4490,10 +4502,10 @@ class VirtualMachine {
     // NOTE: Only check after the last round has been evaluated.
     if(round === this.lastRound) {
       let b = bb;
-      // Iterate over all time steps in this block
+      // Iterate over all time steps in this block.
       let j = -1;
       for(let i = 0; i < abl; i++) {
-        // Index `svt` iterates over types of slack variable (0 - 2)
+        // Index `svt` iterates over types of slack variable (0 - 2).
         for(let svt = 0; svt <= 2; svt++) {
           const
               svl = this.slack_variables[svt],
@@ -4505,12 +4517,12 @@ class VirtualMachine {
                 absl = Math.abs(slack);
             if(absl > VM.NEAR_ZERO) {
               const v = this.variables[vi - 1];
-              // NOTE: for constraints, add 'UB' or 'LB' to its vector for the
-              // time step where slack was used
+              // NOTE: for constraints, add 'UB' or 'LB' to its vector for
+              // the time step where slack was used.
               if(v[1] instanceof BoundLine) {
                 v[1].constraint.slack_info[b] = v[0];
               }
-              if(absl > VM.SIG_DIF_FROM_ZERO) {
+              if(b <= this.nr_of_time_steps && absl > VM.SIG_DIF_FROM_ZERO) {
                 this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
                     `${v[1].displayName} ${v[0]} slack = ${this.sig4Dig(slack)}`);
                 if(v[1] instanceof Product) {
@@ -4556,10 +4568,13 @@ class VirtualMachine {
     // optimization period, hence start by calculating the offset `bb`
     // being the first time step of this block.
     // Blocks are numbered 1, 2, ...
+    let latest_time_step = 0;
     const
         bb = (block - 1) * MODEL.block_length + 1,
         cbl = this.actualBlockLength(block);
 
+    // Start with an empty list of variables to "fixate" in the next block.
+    this.variables_to_fixate = {};
     // FIRST: Calculate the actual flows on links.
     let b, bt, p, pl, ld, ci;
     for(let l in MODEL.links) if(MODEL.links.hasOwnProperty(l) &&
@@ -4574,6 +4589,23 @@ class VirtualMachine {
         // NOTE: Flows may have a delay!
         ld = l.actualDelay(b);
         bt = b - ld;
+        latest_time_step = Math.max(latest_time_step, bt);
+        // If delay < 0 AND this results in a block time beyond the
+        // block length, this means that the level of the FROM node
+        // must be "fixated" in the next block.
+        const nbt = bt - bb - MODEL.block_length + 1;
+        // NOTE: `nbt` (next block time) cannot be beyond the look-ahead
+        // period, as for those time steps the levels are still undefined,
+        // NOR can it be later than the duration of the (negative) delay
+        // on the link. 
+        if(ld < 0 && nbt > 0 && nbt <= MODEL.look_ahead && nbt <= -ld) {
+          this.addNodeToFixate(l.from_node, nbt,
+              // NOTE: Use the level at time `bt` (i.e., in the future)
+              // because that is the optimal level computed for this chunk
+              // (in its look-ahead period) that should be maintained in
+              // the next block.
+              l.from_node.nonZeroLevel(bt));
+        }
         // NOTE: Block index may fall beyond actual chunk length.
         ci = i - ld;
         // NOTE: Use non-zero level here to ignore non-zero values that
@@ -4682,9 +4714,10 @@ class VirtualMachine {
         // INPUT links from priced products generate cash OUT...
         for(let j = 0; j < p.inputs.length; j++) {
           // NOTE: Input links do NOT have a delay.
-          const l = p.inputs[j],
-                af = l.actual_flow[b],
-                fnp = l.from_node.price;
+          const
+              l = p.inputs[j],
+              af = l.actual_flow[b],
+              fnp = l.from_node.price;
           if(af > VM.NEAR_ZERO && fnp.defined) {
             const pp = fnp.result(b);
             if(pp > 0 && pp < VM.PLUS_INFINITY) {
@@ -4697,14 +4730,14 @@ class VirtualMachine {
         }
         // OUTPUT links to priced products generate cash IN ...
         for(let j = 0; j < p.outputs.length; j++) {
-          // NOTE: Actual flows already consider delay!
-          const l = p.outputs[j],
-                ld = l.actualDelay(b),
-                af = l.actual_flow[b],
-                tnp = l.to_node.price;
+          // NOTE: actualFlows already consider delay!
+          const
+              l = p.outputs[j],
+              af = l.actualFlow(b),
+              tnp = l.to_node.price;
           if(af > VM.NEAR_ZERO && tnp.defined) {
-            // NOTE: To get the correct price, again consider delays.
-            const pp = tnp.result(b - ld);
+            // NOTE: Use the price at the time of the actual flow.
+            const pp = tnp.result(b);
             if(pp > 0 && pp < VM.PLUS_INFINITY) {
               ci += pp * af;
             // ... unless the product price is negative; then cash OUT.
@@ -4733,15 +4766,128 @@ class VirtualMachine {
     // at a time because of delays, and also because expressions may refer
     // to values for earlier time steps.
     if(MODEL.infer_cost_prices) {
+      // Keep track of products for which CP will not be computed correctly
+      // due to negative delays.
+      MODEL.products_with_negative_delays = {};
       b = bb;
       for(let i = 0; i < cbl; i++) {
-        if(!MODEL.calculateCostPrices(b)) {
+        // 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)');
         }
         // Move on to the next time step of the block.
         b++;
       }
+      // NOTE: Links with negative delays will not have correct cost
+      // prices as these occur in the future. Having calculated (insofar
+      // as possibe) cost prices of nodes, those on links with negative
+      // delays can now be set to these "future" cost prices.
+      let ts = Object.keys(MODEL.products_with_negative_delays);
+      // Make a separate list of stocks, as these require post-processing.
+      const stocks = [];
+      // NOTE: Proceed backwards in time, using CP = 0 when time step
+      // falls beyond block length + look-ahead.
+      for(let i = ts.length - 1; i >= 0; i--) {
+        const
+            t = parseInt(ts[i]),
+            pwnd = MODEL.products_with_negative_delays[t];
+        // @@TO DO: Sort products in order of precedence to avoid that
+        // when Q1 --> Q2 the CP of Q2 is computed first, and remains
+        // "undefined" while the CP of Q1 can be known.
+        for(let j = 0; j < pwnd.length; j++) {
+          const p = pwnd[j];
+          if(p.is_buffer) addDistinct(p, stocks);
+          // Compute total cost price as sum of inflow * unit cost price.
+          let tcp = 0,
+              taf = 0;
+          for(let k = 0; k < p.inputs.length; k++) {
+            const
+                l = p.inputs[k],
+                d = l.actualDelay(t),
+                td = t - d;
+            // Only compute if t lies within the optimization period.
+            if(td < bb + cbl) {
+              const
+                  // NOTE: actualFlow already considers delays.
+                  af = l.actualFlow(t),
+                  // Get the cost price for the delayed time step.
+                  qcp = l.from_node.costPrice(td);
+              if(qcp > VM.EXCEPTION) {
+                tcp = VM.UNDEFINED;
+                break;
+              }
+              if(af > VM.NEAR_ZERO) {
+                tcp += af * qcp * l.share_of_cost;
+                taf += af;
+              }
+            }
+          }
+          //  CP beyond time horizon
+          if(tcp >= VM.EXCEPTION) {
+            p.cost_price[t] = VM.UNDEFINED;
+          } else if(taf > 0) {
+            // Product cost price is "per unit".
+            p.cost_price[t] = tcp / taf;
+          } else if(p.inputs.length === 1) {
+            // If product has only one input, its cost price can be
+            // inferred from this input even if there is no inflow.
+            const
+                l = p.inputs[0],
+                d = l.actualDelay(t),
+                rr = l.relative_rate.result[t - d];
+            // When t - d is outside period, `rr` is undefined => CP = 0.
+            p.cost_price[t] = (rr ? l.from_node.costPrice(t - d) *
+                rr * l.share_of_cost : 0);
+          } else {
+            p.cost_price[t] = 0;
+          }
+        }
+      }
+      // NOTE: Stocks require special treatment due to working backwards
+      // in time.
+      for(let i = 0; i < stocks.length; i++) {
+        const p = stocks[i];
+        // Get previous stock level and stock price (prior to block start).
+        let sl = p.actualLevel(bb - 1),
+            psp = p.stock_price[bb - 1] || 0;
+        for(let t = bb; t < bb + cbl; t++) {
+          // Subtract outflows from stock level.
+          for(let k = 0; k < p.outputs.length; k++) {
+            const
+                l = p.outputs[k],
+                af = l.actualFlow(t);
+            if(af > VM.NEAR_ZERO) sl -= af;
+          }
+          // Start with total CP = remaining old stock times old price.
+          let tcp = sl * psp;
+          // Add inflows to both level and total CP.
+          for(let k = 0; k < p.inputs.length; k++) {
+            const
+                l = p.inputs[k],
+                af = l.actualFlow(t),
+                d = l.actualDelay(t);
+            if(af > VM.NEAR_ZERO) {
+              const cp = l.from_node.costPrice(t - d);
+              if(cp >= VM.EXCEPTION) {
+                tcp = VM.UNDEFINED;
+                break;
+              }
+              sl += af;
+              tcp += af * cp;
+            }
+          }
+          if(tcp >= VM.EXCEPTION) {
+            psp = VM.UNDEFINED;
+          } else if(sl > VM.NEAR_ZERO) {
+            psp = tcp / sl;
+          } else {
+            psp = 0;
+          }
+          p.stock_price[t] = psp;
+        }
+      }
     }
 
     // THEN: Reset all datasets that are outcomes or serve as "formulas".
@@ -4839,41 +4985,45 @@ class VirtualMachine {
   }
   
   resetTableau() {
-    // Clears tableau data: matrix, rhs and constraint types
-    // NOTE: this reset is called when initializing, and to free up
-    // memory after posting a block to the server
+    // Clears tableau data: matrix, rhs and constraint types.
+    // NOTE: This reset is called when initializing, and to free up
+    // memory after posting a block to the server.
     this.matrix.length = 0;
     this.right_hand_side.length = 0;
     this.constraint_types.length = 0;
   }
   
   initializeTableau(abl) {
-    // `offset` is used to calculate the actual column index for variables
+    // `offset` is used to calculate the actual column index for variables.
     this.offset = 0;
-    // NOTE: vectors are "sparse" (i.e., will contain many 0) and are hence not
-    // represented as arrays but as objects, e.g., {4:1.5, 8:0.3} to represent
-    // an array [0, 0, 0, 1.5, 0, 0, 0, 0.3, 0, 0, 0, ...]
-    // The keys can span the full chunk, so the objects represent vectors that
-    // have a "virtual length" of cols * abl
+    // NOTE: Vectors are "sparse" (i.e., will contain many 0) and are hence
+    // not represented as arrays but as objects, e.g., {4:1.5, 8:0.3} to
+    // represent an array [0, 0, 0, 1.5, 0, 0, 0, 0.3, 0, 0, 0, ...].
+    // The keys can span the full chunk, so the objects represent vectors
+    // that have a "virtual length" of cols * abl.
     this.coefficients = {};
+    this.rhs = 0;
+    // NOTE: VM needs separate "registers" for cash IN and cash OUT
+    // coefficients and RHS because the direction of the cash flow is
+    // dynamic.
     this.cash_in_coefficients = {};
+    this.cash_in_rhs = 0;
     this.cash_out_coefficients = {};
-    // NOTE: cash flow equation coefficients may be divided by a scalar to keep
-    // them amply below the base slack penalty; the scalar is increased by the
-    // VM instruction  VMI_copy_cash_coefficients  so that at the end of the
-    // block setup it equals the highest absolute coefficient in the cash flow
-    // constraint equations; the VM maintains a list of indices of matrix rows
-    // that then need to be scaled
+    this.cash_out_rhs = 0;
+    // NOTE: Cash flow equation coefficients may be divided by a scalar to
+    // keep them amply below the base slack penalty; the scalar is increased
+    // by the VM instruction VMI_add_cash_constraints so that at the end of
+    // the block setup it equals the highest absolute coefficient in the
+    // cash flow constraint equations. The VM maintains a list of indices
+    // of matrix rows that then need to be scaled.
     this.cash_scalar = 1;
     this.cash_constraints = [];
+    // Vector for the objective function coefficients.
     this.objective = {};
+    // Vectors for the bounds on decision variables.
     this.lower_bounds = {};
     this.upper_bounds = {};
-    // NOTE: right-hand side of cash IN/OUT equations will always be 0 as the
-    // actors' cash flows are calculated as C - a1P1 - a2P2 - ... anPn = 0
-    this.rhs = 0;
-    // NOTE: the constraint coefficient matrix and the rhs and ct vectors
-    // have equal length (#rows); the matrix is a list of sparse vectors
+    // Clear the tableau matrix and constraint type and RHS columns.
     this.resetTableau();
     // NOTE: setupBlock only works properly if setupProblem was successful
     // Every variable gets one column per time step => tableau is organized
@@ -4899,7 +5049,7 @@ class VirtualMachine {
         this.is_binary[parseInt(i) + j*this.cols] = true;
       }
     }
-    // Set list with indices of semi-contiuous variables
+    // Set list with indices of semi-contiuous variables.
     this.is_semi_continuous = {};
     for(let i in this.sec_var_indices) if(Number(i)) {
       for(let j = 0; j < abl; j++) {
@@ -5028,7 +5178,7 @@ class VirtualMachine {
     let rem = (MODEL.runLength - MODEL.look_ahead) % MODEL.block_length;
     // If this remainder equals 0, the last block is a full chunk.
     if(rem === 0) return this.chunk_length;
-    // Otherwise, the last block if remainder + look-ahead time steps.
+    // Otherwise, the last block has remainder + look-ahead time steps.
     return rem + MODEL.look_ahead;
   }
   
@@ -5058,6 +5208,33 @@ class VirtualMachine {
     return this.chunk_length * this.cols + this.chunk_variables.length;
   }
   
+  addNodeToFixate(n, bt, level) {
+    // Record that level of node `n` must be fixated for block time `bt`
+    // in the next block by setting it to the specified level.
+    const
+        vi = n.level_var_index,
+        oo = n.on_off_var_index,
+        iz = n.is_zero_var_index;
+    if(!this.variables_to_fixate.hasOwnProperty(vi)) {
+      this.variables_to_fixate[vi] = {};
+    }
+    this.variables_to_fixate[vi][bt] = level;
+    if(oo >= 0) {
+      if(!this.variables_to_fixate.hasOwnProperty(oo)) {
+        this.variables_to_fixate[oo] = {};
+      }
+      this.variables_to_fixate[oo][bt] = (
+          Math.abs(level) < VM.NEAR_ZERO ? 0 : 1);
+    }
+    if(iz >= 0) {
+      if(!this.variables_to_fixate.hasOwnProperty(iz)) {
+        this.variables_to_fixate[iz] = {};
+      }
+      this.variables_to_fixate[iz][bt] = (
+          Math.abs(level) < VM.NEAR_ZERO ? 1 : 0);
+    }
+  }
+  
   writeLpFormat(cplex=false) {
     // NOTE: Up to version 1.5.6, actual block length of last block used
     // to be shorter than the chunk length so as not to go beyond the
@@ -5701,6 +5878,37 @@ Solver status = ${json.status}`);
       this.logMessage(this.block_count, 'Zero columns -- nothing to solve');
       return;
     }
+    // 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);
+    if(keys.length) {
+      const msg = ['NOTE: Due to negative link delays, levels for ' +
+            pluralS(keys.length, 'variable') + ' are pre-set:'];
+      for(let i = 0; i < keys.length; i++) {
+        const
+            vi = parseInt(keys[i]),
+            // NOTE: Subtract 1 because variable list is zero-based.
+            vbl = this.variables[vi - 1], 
+            fv = this.variables_to_fixate[vi],
+            fvk = Object.keys(fv),
+            fvl = [];
+        // Add constraints that fixate the levels directly to the tableau.
+        for(let i = 0; i < fvk.length; i++) {
+          const
+              bt = fvk[i],
+              pl = fv[bt],
+              k = (bt - 1) * VM.cols + vi,
+              row = {};
+          row[k] = 1;
+          VM.matrix.push(row);
+          VM.right_hand_side.push(pl);
+          VM.constraint_types.push(VM.EQ);
+          fvl.push(pl + ' for bt=' + bt);
+        }
+        msg.push(`- ${vbl[1].displayName} [${vbl[0]}]: ${fvl.join(', ')}`);
+      }
+      this.logMessage(this.block_count, msg.join('\n'));
+    }
     this.logMessage(this.block_count,
         'Creating model for block #' + this.blockWithRound);
     this.cbl = CONFIGURATION.progress_needle_interval * 200;
@@ -5898,7 +6106,7 @@ function VMI_push_block_number(x) {
 
 function VMI_push_run_length(x) {
   // Push the run length (excl. look-ahead!).
-  const n = MODEL.end_period - MODEL.start_period + 1;
+  const n = VM.nr_of_time_steps;
   if(DEBUGGING) console.log('push run length N = ' + n);
   x.push(n);
 }
@@ -6177,7 +6385,7 @@ function relativeTimeStep(t, anchor, offset, dtm, x) {
   }
   if(anchor === 'l') {
     // Last: offset relative to the last index in the vector.
-    return MODEL.end_period - MODEL.start_period + 1 + offset;
+    return VM.nr_of_time_steps + offset;
   }
   if(anchor === 's') {
     // Scaled: offset is scaled to time unit of run.
@@ -6565,7 +6773,7 @@ function VMI_push_run_result(x, args) {
       } else if(rrspec.nr !== false) {
         // Run number inferred from local time step of expression
         const
-            rl = MODEL.end_period - MODEL.start_period + 1,
+            rl = VM.nr_of_time_steps,
             range = rangeToList(rrspec.nr, xp.runs.length - 1);
         if(range) {
           const
@@ -6694,7 +6902,7 @@ function VMI_push_statistic(x, args) {
   }
   // Negative time step is evaluated as t = 0 (initial value) t beyond
   // optimization period is evaluated as its last time step
-  const tmax = MODEL.end_period - MODEL.start_period + 1;
+  const tmax = VM.nr_of_time_steps;
   t1 = Math.max(0, Math.min(tmax, t1));
   t2 = Math.max(0, Math.min(tmax, t2));
   // Trace only now that time step range has been computed
@@ -7467,19 +7675,19 @@ function VMI_set_bounds(args) {
       k = VM.offset + vi,
       r = VM.round_letters.indexOf(VM.round_sequence[VM.current_round]),
       // Optional fourth parameter indicates whether the solver's
-      // infinity values should be used
+      // infinity values should be used.
       solver_inf = args.length > 3 && args[3],
       inf_val = (solver_inf ? VM.SOLVER_PLUS_INFINITY : VM.PLUS_INFINITY);
   let l,
       u,
       fixed = (vi in VM.fixed_var_indices[r - 1]);
   if(fixed) {
-    // Set both bounds equal to the level set in the previous round, or to 0
-    // if this is the first round
+    // Set both bounds equal to the level set in the previous round,
+    // or to 0 if this is the first round.
     if(VM.current_round) {
       l = vbl.actualLevel(VM.t);
-      // QUICK PATCH! should resolve that small non-zero process levels
-      // computed in prior round make problem infeasible 
+      // QUICK PATCH! Should resolve that small non-zero process levels
+      // computed in prior round make problem infeasible.
       if(l < 0.0005) l = 0;
     } else {
       l = 0;
@@ -7487,7 +7695,7 @@ function VMI_set_bounds(args) {
     u = l;
     fixed = ' (FIXED ' + vbl.displayName + ')';
   } else {
-    // Set bounds as specified by the two arguments
+    // Set bounds as specified by the two arguments.
     l = args[1];
     if(l instanceof Expression) l = l.result(VM.t);
     if(l === VM.UNDEFINED) l = 0;
@@ -7500,22 +7708,22 @@ function VMI_set_bounds(args) {
     }
     fixed = '';
   }
-  // NOTE: to see in the console whether fixing across rounds works, insert
-  // "fixed !== '' || " before DEBUGGING below
+  // NOTE: To see in the console whether fixing across rounds works, insert
+  // "fixed !== '' || " before DEBUGGING below.
   if(DEBUGGING) {
     console.log(['set_bounds [', k, '] ', vbl.displayName, ' t = ', VM.t,
       ' LB = ', VM.sig4Dig(l), ', UB = ', VM.sig4Dig(u), fixed].join(''));
   }
-  // NOTE: since the VM vectors for lower bounds and upper bounds are
+  // NOTE: Since the VM vectors for lower bounds and upper bounds are
   // initialized with default values (0 for LB, +INF for UB), there is
-  // no need to set them
+  // no need to set them.
   if(l !== 0 || u < inf_val) {
     VM.lower_bounds[k] = l; 
     VM.upper_bounds[k] = u;
     // If associated node is FROM-node of a "peak increase" link, then
     // the "peak increase" variables of this node must have the highest
     // UB of the node (for all t in this block, hence MAX) MINUS their
-    // peak level in previous block
+    // peak level in previous block.
     if(vbl.peak_inc_var_index >= 0) {
       u = Math.max(0, u - vbl.b_peak[VM.block_count - 1]);
       const
@@ -7531,13 +7739,28 @@ function VMI_set_bounds(args) {
 }
 
 function VMI_clear_coefficients() {
+  // Clear the coefficients register and set RHS to zero.
   if(DEBUGGING) console.log('clear_coefficients');
   VM.coefficients = {};
-  VM.cash_in_coefficients = {};
-  VM.cash_out_coefficients = {};
   VM.rhs = 0;
 }
 
+// AUXILIARY FUNCTION (added to support debugging)
+function knownValue(vi, t) {
+  // Return the value of decision variable X that has already been
+  // computed while optimizing a previous block. 
+  const
+      // `vi` is the variable index for X, so use vi-1 for the zero-based
+      // list VM.variables list.
+      vbl = VM.variables[vi - 1],
+      // NOTE: priorValue deals with special cases for binary variables.
+      pv = VM.priorValue(vbl, t);
+  if(DEBUGGING) {
+    console.log(`--known value: ${vbl[0]} ${vbl[1].displayName} @ ${t} = ${pv}`);
+  }
+  return pv;
+}
+
 function VMI_add_const_to_coefficient(args) {
   // `args`: [var_index, number (, delay (, 1))]
   const
@@ -7553,15 +7776,13 @@ function VMI_add_const_to_coefficient(args) {
       d = args[2];
     }
   }
-  const
-      k = VM.offset + vi - d*VM.cols,
-      t = VM.t - d;
+  const k = VM.offset + vi - d*VM.cols;
   if(DEBUGGING) {
     console.log(`add_const_to_coefficient [${k}]: ${VM.sig4Dig(n)}`);
   }
   // A negative delay may result in a variable index beyond the tableau
-  // column range. Such "future variables" should be ignored.
-  if(d < 0 && k > VM.chunk_offset) return;
+  // column range. Such "future variables" should always be ignored.
+  if(k > VM.chunk_offset) return;
   if(k <= 0) {
     // NOTE: If `k` falls PRIOR to the start of the block being solved,
     // this means that the value of the decision variable X for which the
@@ -7569,16 +7790,7 @@ function VMI_add_const_to_coefficient(args) {
     // while solving a previous block. Since the value of X is known,
     // adding n to C is implemented as subtracting n*X from the right hand
     // side of the constraint.
-    // NOTE: Subtract 1 from index `vi` because VM.variables is a 0-based
-    // array.
-    const
-        vbl = VM.variables[vi - 1],
-        pv = VM.priorValue(vbl, t);
-    if(DEBUGGING) {
-      console.log(`--lookup[${k}]: ${vbl[0]} ${vbl[1].displayName} @ ${t} = ${pv}`);
-    }
-    // NOTE: special cases for binary variables!
-    VM.rhs -= pv * n;
+    VM.rhs -= knownValue(vi, VM.t - d) * n;
   } else if(k in VM.coefficients) {
     VM.coefficients[k] += n;
   } else {
@@ -7587,7 +7799,7 @@ function VMI_add_const_to_coefficient(args) {
 }
 
 function VMI_add_const_to_sum_coefficients(args) {
-  // NOTE: used to implement data links with SUM multiplier
+  // NOTE: Used to implement data links with SUM multiplier.
   // `args`: [var_index, number, delay (, 1)]
   const vi = args[0];
   let d = args[2].object.actualDelay(VM.t),
@@ -7606,16 +7818,11 @@ function VMI_add_const_to_sum_coefficients(args) {
     d = -d;
   }
   for(let i = 0; i <= d; i++) {
-    // A negative delay may result in a variable index beyond the tableau
-    // column range. Such "future variables" should be ignored.
+    // Variables beyond the chunk length should be ignored.
     if(k > VM.chunk_offset) return;
     if(k <= 0) {
-      // See NOTE in VMI_add_const_to_coefficient instruction
-      const vbl = VM.variables[vi - 1];
-      if(DEBUGGING) {
-        console.log('--lookup[' + k + ']: ' + vbl[0] + ' ' + vbl[1].displayName);
-      }
-      VM.rhs -= VM.priorValue(vbl, t) * n;
+      // See NOTE in VMI_add_const_to_coefficient instruction.
+      VM.rhs -= knownValue(vi, t) * n;
     } else if(k in VM.coefficients) {
       VM.coefficients[k] += n;
     } else {
@@ -7632,29 +7839,24 @@ function VMI_add_var_to_coefficient(args) {
   let d = 0;
   if(args.length > 2 && args[2] instanceof Expression) {
     d = args[2].object.actualDelay(VM.t);
-    // 4th argument = 1 indicates "delay + 1"
+    // 4th argument = 1 indicates "delay + 1".
     if(args.length > 3 && args[3]) d++;
   }
   const
       k = VM.offset + vi - d*VM.cols,
       t = VM.t - d;
   let r = args[1].result(t);
-  // Optional 5th parameter is a constant multiplier
+  // Optional 5th parameter is a constant multiplier.
   if(args.length > 4) r *= args[4];
   if(DEBUGGING) {
     console.log('add_var_to_coefficient [' + k + ']: ' +
         args[1].variableName + ' (t = ' + t + ')');
   }
-  // A negative delay may result in a variable index beyond the tableau
-  // column range. Such "future variables" should be ignored.
+  // Ignore "future variables".
   if(k > VM.chunk_offset) return;
   if(k <= 0) {
-    // See NOTE in VMI_add_const_to_coefficient instruction
-    const vbl = VM.variables[vi - 1];
-    if(DEBUGGING) {
-      console.log('--lookup[' + k + ']: ' + vbl[0] + ' ' + vbl[1].displayName);
-    }
-    VM.rhs -= VM.priorValue(vbl, t) * r;
+    // See NOTE in VMI_add_const_to_coefficient instruction.
+    VM.rhs -= knownValue(vi, t) * r;
   } else if(k in VM.coefficients) {
     VM.coefficients[k] += r;
   } else {
@@ -7682,18 +7884,13 @@ function VMI_add_var_to_weighted_sum_coefficients(args) {
     d = -d;
   }
   for(let i = 0; i <= d; i++) {
-    // A negative delay may result in a variable index beyond the tableau
-    // column range. Such "future variables" should be ignored.
+    // Ignore "future variables".
     if(k > VM.chunk_offset) return;
     let r = v.result(t);
     if(args.length > 3) r /= (d + 1);
     if(k <= 0) {
       // See NOTE in VMI_add_const_to_coefficient instruction
-      const vbl = VM.variables[vi - 1];
-      if(DEBUGGING) {
-        console.log('--lookup[' + k + ']: ' + vbl[0] + ' ' + vbl[1].displayName);
-      }
-      VM.rhs -= VM.priorValue(vbl, t) * r;
+      VM.rhs -= knownValue(vi, t) * r;
     } else if(k in VM.coefficients) {
       VM.coefficients[k] += r;
     } else {
@@ -7715,22 +7912,15 @@ function VMI_subtract_const_from_coefficient(args) {
     // 4th argument indicates "delay + 1"
     if(args.length > 3) d++;
   }
-  const
-      k = VM.offset + vi - d*VM.cols,
-      t = VM.t - d;
+  const k = VM.offset + vi - d*VM.cols;
   if(DEBUGGING) {
     console.log('subtract_const_from_coefficient [' + k + ']: ' + VM.sig4Dig(n));
   }
-  // A negative delay may result in a variable index beyond the tableau
-  // column range. Such "future variables" should be ignored.
+  // Ignore "future variables".
   if(k > VM.chunk_offset) return;
   if(k <= 0) {
     // See NOTE in VMI_add_const_to_coefficient instruction
-    const vbl = VM.variables[vi - 1];
-    if(DEBUGGING) {
-      console.log('--lookup[' + k + ']: ' + vbl[0] + ' ' + vbl[1].displayName);
-    }
-    VM.rhs += VM.priorValue(vbl, t) * n;
+    VM.rhs += knownValue(vi, VM.t - d) * n;
   } else if(k in VM.coefficients) {
     VM.coefficients[k] -= n;
   } else {
@@ -7764,16 +7954,11 @@ function VMI_subtract_var_from_coefficient(args) {
     console.log('subtract_var_from_coefficient [' + k + ']: ' +
         args[1].variableName + ' (t = ' + t + ')');
   }
-  // A negative delay may result in a variable index beyond the tableau
-  // column range. Such "future variables" should be ignored.
+  // Ignore "future variables".
   if(k > VM.chunk_offset) return;
   if(k <= 0) {
-    // See NOTE in VMI_add_const_to_coefficient instruction
-    const vbl = VM.variables[vi - 1];
-    if(DEBUGGING) {
-      console.log('--lookup[' + k + ']: ' + vbl[0] + ' ' + vbl[1].displayName);
-    }
-    VM.rhs += VM.priorValue(vbl, t) * r;
+    // See NOTE in VMI_add_const_to_coefficient instruction.
+    VM.rhs += knownValue(vi, t) * r;
   } else if(k in VM.coefficients) {
     VM.coefficients[k] -= r;
   } else {
@@ -7783,9 +7968,9 @@ function VMI_subtract_var_from_coefficient(args) {
 
 function VMI_update_cash_coefficient(args) {
   // `args`: [flow, type, level_var_index, delay, x1, x2, ...]
-  // NOTE: flow is either CONSUME or PRODUCE; type can be ONE_C (one
+  // NOTE: Flow is either CONSUME or PRODUCE; type can be ONE_C (one
   // constant parameter x1), TWO_X (two expressions x1 and x2), THREE_X
-  // (three expressions x1, x2 and x3) or SPIN_RES or PEAK_INC (see below)
+  // (three expressions x1, x2 and x3) or SPIN_RES or PEAK_INC (see below).
   let d = 0;
   const
       flow = args[0],
@@ -7793,52 +7978,68 @@ function VMI_update_cash_coefficient(args) {
       vi = args[2],
       dx = args[3];
   if(dx instanceof Expression) {
+    // When delay is an expression, `dx.object` is the delayed link.
     d = dx.object.actualDelay(VM.t);
-    // Extra argument indicates "delay + 1"
+    // Extra argument indicates "delay + 1" (for delta-multipliers).
     if((type === VM.ONE_C && args.length === 6) ||
         (type === VM.TWO_X && args.length === 7)) d++;
   }
+  // NOTE: When delay < 0, the coefficient must be set for a matrix row
+  // that will be added to the tableau for some later VM.t.
   // `k` is the tableau column index of the variable that affects the CF
   let k = (type === VM.PEAK_INC ? VM.chunk_offset + vi :
       VM.offset + vi - d*VM.cols);
-  // NOTE: delay > 0 affects only which variable is to be used,
-  // not the expressions for rates or prices!
-  const t = VM.t - d;
-  // NOTE: this instruction is used only for objective function
-  // coefficients; previously computed decision variables and variables
-  // beyond the tableau column range (when delay < 0) can be ignored.
-  if(k <= 0 || k > VM.chunk_offset) return;
-  // NOTE: peak increase can generate cash only at the first time
+  // NOTE: Variables beyond the tableau column range (when delay < 0) can
+  // be ignored.
+  if(k > VM.chunk_offset) return;
+  // NOTE: Peak increase can generate cash only at the first time
   // step of a block (when VM.offset = 0) and at the first time step
-  // of the look-ahead period (when VM.offset = block length)
+  // of the look-ahead period (when VM.offset = block length).
   if(type === VM.PEAK_INC &&
       VM.offset > 0 && VM.offset !== MODEL.block_length) return;
-  // First compute the result to be processed
+  // NOTE: Delay affects only which variable is to be used. The level of
+  // this variable is then the delayed production volume to be priced at
+  // the *current* time.
+  // First compute the result to be processed.
   let r = 0;
   if(type === VM.ONE_C) {
     r = args[4];
   } else if(type === VM.TWO_X || type === VM.PEAK_INC) {
-    // NOTE: "peak increase" always passes two expressions
+    // NOTE: "peak increase" always passes two expressions.
+    // The first expression determines the price.
     r = args[4].result(VM.t) * args[5].result(VM.t);
   } else if(type === VM.THREE_X) {
+    // NOTE: Here, too, the first expression determines the price. 
     r = args[4].result(VM.t) * args[5].result(VM.t) * args[6].result(VM.t);
   } else if(type === VM.SPIN_RES) {
-    // "spinning reserve" equals UB - level if level > 0, or 0
+    // "spinning reserve" equals UB - level if level > 0, or 0.
     // The cash flow then equals ON/OFF*UB*price*rate - level*price*rate.
     // The ON/OFF variable index is passed as third argument, hence `plvi`
     // (process level variable index) as first extra parameter, plus three
-    // expressions (UB, price, rate)
+    // expressions (UB, price, rate).
     const
         plvi = args[4],
-        // NOTE: column of second variable will be relative to same offset
+        // NOTE: Column of second variable will be relative to same offset.
         plk = k + plvi - vi,
         ub = args[5].result(VM.t),
         price_rate = args[6].result(VM.t) * args[7].result(VM.t);
     r = ub * price_rate;
-    // NOTE: the sign of r determines whether this spinning reserve will
-    // generate cash IN or cash OUT; the *subtracted* part hence be ADDED
-    // if r > 0, and SUBTRACTED if r < 0 (unlike the "primary" part r itself)
-    if(r > 0) {
+    // NOTE: The sign of r determines whether this spinning reserve will
+    // generate cash IN or cash OUT. The *subtracted* part (production level
+    // times price_rate) should hence be ADDED if r > 0, and SUBTRACTED
+    // if r < 0 (unlike the "primary" part r itself).
+    if(plk <= 0) {
+      // NOTE: If `plk` falls PRIOR to the start of the block being solved,
+      // update the right hand side of the cash flow constraint.
+      // Assume that the known production level is be non-negative, so its
+      // sign does not alter the flow direction.
+      const pl = knownValue(plvi, VM.t - d);
+      if(r > 0) {
+        VM.cash_in_rhs -= pl * price_rate;
+      } else {
+        VM.cash_out_rhs += pl * price_rate;      
+      }
+    } else if(r > 0) {
       if(plk in VM.cash_in_coefficients) {
         VM.cash_in_coefficients[plk] += price_rate;
       } else {
@@ -7852,27 +8053,38 @@ function VMI_update_cash_coefficient(args) {
       }
     }
   }
-  // NOTE: for spinning reserve and highest increment, flow will always
-  // be PRODUCE
+  // NOTE: For spinning reserve and highest increment, flow will always
+  // be PRODUCE.
   if(flow === VM.CONSUME) r = -r;
   if(DEBUGGING) {
-    const vbl = (vi <= this.cols ? VM.variables[vi - 1] :
-        VM.chunk_variables[vi - this.cols]); //@@@ TO MAKE CORRECT FOR chunk vars!
-    console.log(['update_cash_coefficient [', k, ']: ', vbl[0], ' ',
-        vbl[1].displayName, ' (t = ', t, ') ', VM.CF_CONSTANTS[type], ' ',
-        VM.CF_CONSTANTS[flow], ' r = ', VM.sig4Dig(r)].join(''));
-  }
-  // Use look-ahead peak increase when offset > 0
+    const vbl = (vi <= VM.cols ? VM.variables[vi - 1] :
+        VM.chunk_variables[vi - VM.cols]);
+    //@@@ MESSAGE TO MAKE CORRECT FOR chunk vars!
+    console.log(['update_cash_coefficient [', k, ']: ',
+        vbl[1].displayName, '[' + vbl[0] + '] (t = ', VM.t, ') ',
+        VM.CF_CONSTANTS[type], ' ', VM.CF_CONSTANTS[flow], ' r = ',
+        VM.sig4Dig(r)].join(''));
+  }
+  // Use look-ahead peak increase when offset > 0.
   if(type === VM.PEAK_INC && VM.offset) k++;
-  // Then update the cash flow: cash IN if r > 0, otherwise cash OUT  
-  if(r > 0) {
+  // Then update the cash flow: cash IN if r > 0, otherwise cash OUT. 
+  if(k <= 0) {
+    // NOTE: If `k` falls PRIOR to the start of the block being solved,
+    // subtract the known prior value of the decision variable from the
+    // right hand side of the cash flow constraint.
+    if(r > 0) {
+      VM.cash_in_rhs += knownValue(vi, VM.t - d) * r;
+    } else {
+      VM.cash_out_rhs -= knownValue(vi, VM.t - d) * r;      
+    }
+  } else if(r > 0) {
     if(k in VM.cash_in_coefficients) {
       VM.cash_in_coefficients[k] -= r;
     } else {
       VM.cash_in_coefficients[k] = -r;
     }
   } else if(r < 0) {
-    // NOTE: Test for r < 0 because no action is needed if r = 0
+    // NOTE: Test for r < 0 because no action is needed if r = 0.
     if(k in VM.cash_out_coefficients) {
       VM.cash_out_coefficients[k] += r;
     } else {
@@ -7882,7 +8094,7 @@ function VMI_update_cash_coefficient(args) {
 }
 
 function VMI_add_throughput_to_coefficient(args) {
-  // Special instruction to deal with throughput calculation
+  // Special instruction to deal with throughput calculation.
   // Function: to add the contribution of variable X to the level of
   // variable Z when Z depends (a.o.) on the throughput of variable Y, i.e.,
   // X --(r2,d2)--> Y --(r1,d1)--> Z
@@ -7892,8 +8104,9 @@ function VMI_add_throughput_to_coefficient(args) {
       vi = args[0],
       d1 = args[2].object.actualDelay(VM.t),
       d2 = (args[4] ? args[4].object.actualDelay(VM.t) : 0),
-      k = VM.offset + vi - (d1 + d2)*VM.cols,
-      t = VM.t - d1 - d2,
+      dsum = d1 + d2,
+      k = VM.offset + vi - dsum * VM.cols,
+      t = VM.t - dsum,
       // Compute the value to be added to the coefficient
       v = args[1].result(VM.t) * args[3].result(VM.t - d1);
   if(DEBUGGING) {
@@ -7901,8 +8114,7 @@ function VMI_add_throughput_to_coefficient(args) {
         args[1].variableName + ' * ' + args[3].variableName +
         ' (t = ' + VM.t + ')');
   }
-  // A negative delay may result in a variable index beyond the tableau
-  // column range. Such "future variables" should be ignored.
+  // Ignore "future variables".
   if(k > VM.chunk_offset) return;
   if(k <= 0) {
     const vbl = VM.variables[vi - 1];
@@ -8012,27 +8224,69 @@ function VMI_add_constraint(ct) {
   }
 }
 
-function VMI_copy_cash_coefficients(flow) {
-  // Overwrites the coefficients vector with the specified cash coefficients
-  // vector (cash IN for production and cash OUT for consumption)
+function VMI_add_cash_constraints(args) {
+  // args = [cash IN variable index, cash OUT variable index]
+  // Overwrites the coefficients vector with the cash coefficients
+  // vector specified by the first argument (cash IN for production,
+  // cash OUT for consumption). The second argument is passed only for
+  // tracing purposes.
   if(DEBUGGING) {
-    console.log('copy_cash_coefficients: ' + VM.CF_CONSTANTS[flow]);
+    console.log('add cash constraints for ',
+        VM.variables[args[0]][1].displayName, '(t = ' + VM.t + ')');
   }
-  if(flow === VM.PRODUCE) {
-    VM.coefficients = Object.assign({}, VM.cash_in_coefficients);
-  } else {
-    VM.coefficients = Object.assign({}, VM.cash_out_coefficients);
+  if(!VM.add_constraints_flag) {
+    console.log('Constraint NOT added!');
+    return;
   }
-  // NOTE: This instruction also keeps track of the highest cash flow constraint
-  // coefficient (to be used for scaling these constraint equations)
-  for(let i in VM.coefficients) if(VM.coefficients.hasOwnProperty(i)) {
-    VM.cash_scalar = Math.max(VM.cash_scalar, Math.abs(VM.coefficients[i]));
+  // Add a constraint for cash IN.
+  let row = {};
+  for(let i in VM.cash_in_coefficients) if(VM.cash_in_coefficients.hasOwnProperty(i)) {
+    const
+        c = VM.cash_in_coefficients[i],
+        ac = Math.abs(c);
+    // Do not add variables having near-zero coefficients.
+    if(ac > VM.NEAR_ZERO) {
+      row[i] = c;
+      // NOTE: This instruction also keeps track of the highest absolute
+      // cash flow constraint coefficient, so it can be used for scaling
+      // these constraint equations.
+      VM.cash_scalar = Math.max(VM.cash_scalar, ac);
+    }
+  }
+  // To permit such scaling, this instruction maintains a list of cash
+  // constraint row indices, as these are the equations that need to be
+  // scaled once the tableau is complete.
+  VM.cash_constraints.push(VM.matrix.length);
+  // Set coefficient for the cash IN variable to 1.
+  row[VM.offset + args[0]] = 1;
+  // Add the constraint to the tableau.
+  VM.matrix.push(row);
+  VM.right_hand_side.push(VM.cash_in_rhs);
+  VM.constraint_types.push(VM.EQ);
+  // Clear the cash IN coefficient register and RHS.
+  VM.cash_in_coefficients = {};
+  VM.cash_in_rhs = 0;
+  // Now likewise add a constraint for cash OUT.
+  row = {};
+  for(let i in VM.cash_out_coefficients) if(VM.cash_out_coefficients.hasOwnProperty(i)) {
+    const
+        c = VM.cash_out_coefficients[i],
+        ac = Math.abs(c);
+    if(ac > VM.NEAR_ZERO) {
+      row[i] = c;
+      VM.cash_scalar = Math.max(VM.cash_scalar, ac);
+    }
   }
-  // NOTE: To permit such scaling, this instruction creates a list of constraint
-  // row indices, as these are the equations that need to be scaled
   VM.cash_constraints.push(VM.matrix.length);
-  // Always set RHS to 0 as cash flow constraints are EQ 0 constraints
-  VM.rhs = 0;
+  // Add the cash OUT variable index.
+  row[VM.offset + args[1]] = 1;
+  // Add the constraint to the tableau.
+  VM.matrix.push(row);
+  VM.right_hand_side.push(VM.cash_out_rhs);
+  VM.constraint_types.push(VM.EQ);
+  // Clear the cash OUT coefficients register and RHS (just to be sure).
+  VM.cash_out_coefficients = {};
+  VM.cash_out_rhs = 0;
 }
 
 function VMI_add_bound_line_constraint(args) {
@@ -8285,7 +8539,7 @@ function VMI_profitable_units(x) {
         mpa = d[3].attribute,
         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); 
+        nt = (d.length > 5 ? d[5] : VM.nr_of_time_steps); 
     // Handle exceptional values of `uc` and `mc`.
     if(uc <= VM.BEYOND_MINUS_INFINITY || mc <= VM.BEYOND_MINUS_INFINITY) {
       x.retop(Math.min(uc, mc));
@@ -8423,7 +8677,7 @@ function VMI_highest_cumulative_consecutive_deviation(x) {
       // 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;
+        const nt = VM.nr_of_time_steps;
         for(let t = 1; t <= nt; t++) x.result(t);
       }
       vector = x.vector;
@@ -8574,7 +8828,7 @@ function correlation_or_slope(x, c_or_s) {
         // 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;
+          const nt = VM.nr_of_time_steps;
           for(let t = 1; t <= nt; t++) eq.result(t, x.wildcard_vector_index);
         }
         vector[k].v = eq.vector;
@@ -8601,7 +8855,7 @@ function correlation_or_slope(x, c_or_s) {
         x.retop(x.cache[cache_key]);
         return;
       }
-      if(true||DEBUGGING) {
+      if(DEBUGGING) {
         console.log(`-- ${vmi}(${vector.x.name}, ${vector.y.name})`);
       }
       // NOTE: Vectors should have equal length.