linny-r 2.0.4 → 2.0.5

package/package.json

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

package/static/index.html

@@ -378,7 +378,9 @@ and move the cursor over the status bar">
          title="Add cluster">
     <img id="note-btn" class="btn toggle enab sep" src="images/note.png"
          title="Add note">
-    <img id="clone-btn" class="btn disab sep" src="images/clone.png"
+    <img id="replace-btn" class="btn disab" src="images/replace-product.png"
+         title="Replace selected product by some other product (Alt-P)">
+    <img id="clone-btn" class="btn disab" src="images/clone.png"
          title="Copy selection (Ctrl-C) &ndash; Alt-click to clone (Alt-C)">
     <img id="paste-btn" class="btn disab sep" src="images/paste.png"
          title="Paste selection (Ctrl-V)">
@@ -1375,6 +1377,9 @@ NOTE: Products directly linked to such processes should have a proportional unit
               <option id="link-shutdown" value="10">
                 &#x25BC; (shut-down: 1 if X[t-1] > 0 &and; X[t] = 0, otherwise 0)
               </option>
+              <option id="link-slack" value="12">
+                &#x21A5; (available capacity: UB - X[t])
+              </option>
               <option id="link-spinning" value="8">
                 &#x2934; (spinning reserve: UB - X[t] if X[t] > 0, otherwise 0)
               </option>

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

@@ -418,7 +418,7 @@ class GUIController extends Controller {
     // Initialize controller buttons.
     this.node_btns = ['process', 'product', 'link', 'constraint',
         'cluster', 'module', 'note'];
-    this.edit_btns = ['clone', 'paste', 'delete', 'undo', 'redo'];
+    this.edit_btns = ['replace', 'clone', 'paste', 'delete', 'undo', 'redo'];
     this.model_btns = ['settings', 'save', 'repository', 'actors',
         'dataset', 'equation', 'chart', 'sensitivity', 'experiment',
         'diagram', 'savediagram', 'finder', 'monitor', 'tex', 'solve'];
@@ -599,6 +599,8 @@ class GUIController extends Controller {
             UI.copySelection();
           }
         });
+    this.buttons.replace.addEventListener('click',
+        () => UI.replaceSelectedProduct());
     this.buttons.paste.addEventListener('click',
         () => UI.pasteSelection());
     this.buttons['delete'].addEventListener('click',
@@ -827,7 +829,7 @@ class GUIController extends Controller {
     this.modals.move.cancel.addEventListener('click',
         () => UI.doNotMoveNode());
     
-    // The REPLACE dialog appears when a product is Ctrl-clicked.
+    // The REPLACE dialog appears when a product is Shift-Alt-clicked.
     this.modals.replace.ok.addEventListener('click',
         () => UI.replaceProduct()); 
     this.modals.replace.cancel.addEventListener('click',
@@ -925,6 +927,9 @@ class GUIController extends Controller {
     UNDO_STACK.clear();
     // Autosaving should start anew.
     AUTO_SAVE.setAutoSaveInterval();
+    // Finder dialog is closed, but  may still display results for
+    // previous model.
+    FINDER.updateDialog();
     // Signal success or failure.
     return loaded;
   }
@@ -1132,7 +1137,6 @@ class GUIController extends Controller {
                 'confirm when prompted by your browser.');
               // Hide "update" button in server dialog.
               UI.modals.server.element('update').style.display = 'none';
-              return;
             } else {
               // Inform user that install appears to have failed.
               msg.push(
@@ -1142,7 +1146,8 @@ class GUIController extends Controller {
             }
             md.element('msg').innerHTML = msg.join('<br>');
             // Reload `index.html`. This will start Linny-R anew.
-            window.open('./', '_self');
+            // NOTE: Wait for 2 seconds so the message can be read.
+            setTimeout(() => { window.open('./', '_self'); }, 2000);
           }
         })
       .catch((err) => {
@@ -1591,7 +1596,7 @@ class GUIController extends Controller {
     // Updates the buttons on the main GUI toolbars
     const
         node_btns = 'process product link constraint cluster note ',
-        edit_btns = 'clone paste delete undo redo ',
+        edit_btns = 'replace clone paste delete undo redo ',
         model_btns = 'settings save actors dataset equation chart ' +
             'diagram savediagram finder monitor solve';
     if(MODEL === null) {
@@ -1617,9 +1622,30 @@ class GUIController extends Controller {
     this.enableButtons(node_btns + model_btns);
     this.active_button = this.stayActiveButton;
     this.disableButtons(edit_btns);
-    if(MODEL.selection.length > 0) this.enableButtons('clone delete');
+    if(MODEL.selection.length > 0) {
+      this.enableButtons('clone delete');
+      // Replace applies only to a single product.
+      if(MODEL.selection.length === 1) {
+        const p = MODEL.selection[0];
+        if(p instanceof Product) {
+          const
+              b = this.buttons.replace,
+              t = 'Replace selected product by some other product (Alt-P)';
+          // Differentiate between product types, as products can be
+          // replaced only by products of the same type.
+          if(p.is_data) {
+            b.title = t.replaceAll('product', 'data product');
+            b.src = 'images/replace-data-product.png';
+          } else {
+            b.title = t;
+            b.src = 'images/replace-product.png';            
+          }
+          this.enableButtons('replace');
+        }
+      }
+    }
     if(this.canPaste) this.enableButtons('paste');
-    // Only allow target seeking when some target or process constraint is defined
+    // Only allow soling when some target or process constraint is defined.
     if(MODEL.hasTargets) this.enableButtons('solve');
     var u = UNDO_STACK.canUndo;
     if(u) {
@@ -2315,13 +2341,16 @@ class GUIController extends Controller {
       } else if(alt && code === 'KeyR') {
         // Alt-R means: run to diagnose infeasible/unbounded problem.
         VM.solveModel(true);
-      } else if(alt && ['KeyC', 'KeyM'].indexOf(code) >= 0) {
-        // Special shortcut keys for "clone selection" and "model settings".
+      } else if(alt && ['KeyC', 'KeyM', 'KeyP'].indexOf(code) >= 0) {
+        // Special shortcut keys for "clone selection", "model settings"
+        // and "replace product".
         const be = new Event('click');
         if(code === 'KeyC') {
           this.buttons.clone.dispatchEvent(be);
-        } else {
+        } else if(code === 'KeyM') {
           this.buttons.settings.dispatchEvent(be);
+        } else if(code === 'KeyP') {
+          this.buttons.replace.dispatchEvent(be);
         }
       } else if(!e.shiftKey && !alt &&
           (!topmod || ['KeyA', 'KeyC', 'KeyV'].indexOf(code) < 0)) {
@@ -2333,7 +2362,9 @@ class GUIController extends Controller {
             CONSTRAINT_EDITOR.deleteBoundLine();
           } else if(!this.hidden('variable-modal')) {
             CHART_MANAGER.deleteVariable();
-          } else {
+          } else if(!topmod) {
+            // Do not delete entity from model diagram when some modal
+            // is showing. 
             this.buttons['delete'].dispatchEvent(new Event('click'));
           }
         } else if (code === 'Period' && (e.ctrlKey || e.metaKey)) {
@@ -4276,6 +4307,15 @@ console.log('HERE name conflicts', name_conflicts, mapping);
       soc = 0; 
       this.warn('Cost can only be attributed to level-based links');
     }
+    // For multipliers requiring a binary variable, and also for those
+    // based on the node's upper bound, warn the modeler when the UB for
+    // this node is infinite or unspecified.
+    if(VM.LM_NEEDING_ON_OFF.indexOf(m) >= 0 || m === VM.LM_AVAILABLE_CAPACITY) {
+      if(!l.from_node.upper_bound.text) {
+        UI.warn('Infinite upper bound of <strong>' + l.from_node.displayName +
+                `</strong> will cause issues for ${VM.LM_SYMBOLS[m]} link`);
+      }
+    }
     // NOTE: share of cost is input as a percentage, but stored as a floating
     // point value between 0 and 1
     l.share_of_cost = soc / 100;
@@ -4307,9 +4347,17 @@ console.log('HERE name conflicts', name_conflicts, mapping);
         'constraint-to-name').innerHTML = c.to_node.displayName;
     CONSTRAINT_EDITOR.showDialog();
   }
+  
+  replaceSelectedProduct() {
+    // Check whether selection contains one product, and if so, prompt
+    // for replacement.
+    if(MODEL.selection.length !== 1) return;
+    const p = MODEL.selection[0];
+    if(p instanceof Product) this.showReplaceProductDialog(p);
+  }
 
   showReplaceProductDialog(p) {
-    // Prompts for a product (different from `p`) by which `p` should be
+    // Prompt for a product (different from `p`) by which `p` should be
     // replaced for the selected product position
     const pp = MODEL.focal_cluster.indexOfProduct(p);
     if(pp >= 0) {

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

@@ -4076,16 +4076,24 @@ class LinnyRModel {
   replaceProduct(p, r, global) {
     const
        ppi = this.focal_cluster.indexOfProduct(p),
-       // NOTE: record whether `r` is show in focal cluster 
+       // NOTE: Record whether `r` is shown in focal cluster.
        rshown = this.focal_cluster.indexOfProduct(r) >= 0;
     // NOTE: since `ppi` should always be >= 0
     if(ppi >= 0) {
-      // Build list of information needed for "undo"
-      const undo_info = {p: p.displayName, r: r.displayName, g: global,
-          lf: [], lt: [], cf: [], ct: [], cl: []};
-      // Keep track of redirected links
+      // Build list of information needed for "undo".
+      const undo_info = {
+          p: p.displayName,
+          r: r.displayName,
+          g: global,
+          lf: [],
+          lt: [],
+          cf: [],
+          ct: [],
+          cl: []
+        };
+      // Keep track of redirected links.
       const rl = [];
-      // First replace product in (local) links
+      // First replace product in (local) links.
       for(let i = p.inputs.length - 1; i >= 0; i--) {
         const l = p.inputs[i];
         if(global || l.hasArrow) {
@@ -4093,7 +4101,7 @@ class LinnyRModel {
           ml.copyPropertiesFrom(l);
           this.deleteLink(l);
           rl.push(ml);
-          // NOTE: push identifier of *modified* link
+          // NOTE: push identifier of *modified* link.
           undo_info.lt.push(ml.identifier);
         }
       }
@@ -4107,7 +4115,7 @@ class LinnyRModel {
         }
       }
       // Then also replace product in (local) constraints
-      // (also keeping track of affected constraints)
+      // (also keeping track of affected constraints).
       const rc = [];
       for(let k in this.constraints) {
         if(this.constraints.hasOwnProperty(k)) {
@@ -4125,26 +4133,26 @@ class LinnyRModel {
           }
         }
       }
-      // Replace `p` by `r` as the positioned product
+      // Replace `p` by `r` as the positioned product.
       const pp = this.focal_cluster.product_positions[ppi];
       undo_info.x = pp.x;
       undo_info.y = pp.y;
       pp.product = r;
-      // Change coordinates only if `r` is also shown in the focal cluster
+      // Change coordinates only if `r` is also shown in the focal cluster.
       if(rshown) {
         pp.x = r.x;
         pp.y = r.y;
       }
-      // Likewise replace product of other placeholders of `p` by `r`
+      // Likewise replace product of other placeholders of `p` by `r`.
       for(let k in this.clusters) if(this.clusters.hasOwnProperty(k)) {
         const
             c = this.clusters[k],
             ppi = c.indexOfProduct(p);
-        // NOTE: when local, replace only if sub-cluster is in view
+        // NOTE: When local, replace only if sub-cluster is in view...
         if(ppi >= 0 && (global || this.focal_cluster.containsCluster(c))) {
           const pp = c.product_positions[ppi];
-          // And then it MAY be that within this sub-cluster, the local
-          // links to `p` were NOT redirected
+          // ... and then it MAY be that within this sub-cluster, the local
+          // links to `p` were NOT redirected.
           const ll = [];
           for(let i = 0; i < p.inputs.length; i++) {
             const l = p.inputs[i];
@@ -4169,7 +4177,7 @@ class LinnyRModel {
       }
       // Now prepare for undo, so that deleteNode can add its XML 
       UNDO_STACK.push('replace', undo_info);
-      // Delete original product `p` if it has no more product positions
+      // Delete original product `p` if it has no more product positions.
       if(!this.top_cluster.containsProduct(p)) this.deleteNode(p);
     }
     // Prepare for redraw

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

@@ -2157,6 +2157,10 @@ class VirtualMachine {
     // diagnostic purposes -- see below.
     this.PLUS_INFINITY = 1e+25;
     this.MINUS_INFINITY = -1e+25;
+    // Expression results having an infinite term may be less than infinity,
+    // but still exceptionally high, and this should be shown.
+    this.NEAR_PLUS_INFINITY = this.PLUS_INFINITY / 200;
+    this.NEAR_MINUS_INFINITY = this.MINUS_INFINITY / 200;
     // As of version 1.8.0, Linny-R imposes no +INF bounds on processes
     // unless diagnosing an unbounded problem. For such diagnosis, the
     // (relatively) low value 9.999999999e+9 is used.
@@ -2218,11 +2222,12 @@ class VirtualMachine {
     this.LM_FIRST_COMMIT = 9; // Symbol: hollow asterisk
     this.LM_SHUTDOWN = 10; // Symbol: thick chevron down
     this.LM_PEAK_INC = 11; // Symbol: plus inside triangle ("peak-plus")
+    this.LM_AVAILABLE_CAPACITY = 12; // Symbol: up-arrow with baseline
     // List of link multipliers that require binary ON/OFF variables
     this.LM_NEEDING_ON_OFF = [5, 6, 7, 8, 9, 10];
     this.LM_SYMBOLS = ['', '\u21C9', '\u0394', '\u03A3', '\u03BC', '\u25B2',
-        '+', '0', '\u2934', '\u2732', '\u25BC', '\u2A39'];
-    this.LM_LETTERS = ' TDSMU+0RFDP';
+        '+', '0', '\u2934', '\u2732', '\u25BC', '\u2A39', '\u21A5'];
+    this.LM_LETTERS = ' TDSMU+0RFDPA';
     
     // VM max. expression stack size.
     this.MAX_STACK = 200;
@@ -2560,14 +2565,14 @@ class VirtualMachine {
     if(n <= this.CYCLIC) return [true, '#CYCLE!'];
     // Any other number less than or equal to 10^30 is considered as
     // minus infinity.
-    if(n <= this.MINUS_INFINITY) return [true, '-\u221E'];
+    if(n <= this.NEAR_MINUS_INFINITY) return [true, '-\u221E'];
     // Other special values are very big POSITIVE numbers, so start
     // comparing `n` with the highest value.
     if(n >= this.COMPUTING) return [true, '\u25A6']; // Checkered square
     // NOTE: The prettier circled bold X 2BBF does not display on macOS !!
     if(n >= this.NOT_COMPUTED) return [true, '\u2297']; // Circled X
     if(n >= this.UNDEFINED) return [true, '\u2047']; // Double question mark ??
-    if(n >= this.PLUS_INFINITY) return [true, '\u221E'];
+    if(n >= this.NEAR_PLUS_INFINITY) return [true, '\u221E'];
     if(n === this.NO_COST) return [true, '\u00A2']; // c-slash (cent symbol)
     return [false, n];
   }
@@ -3693,6 +3698,15 @@ class VirtualMachine {
                       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_REMAINING_CAPACITY) {
+                  // "remaining capacity" equals UB - level. This is a
+                  // simpler version of "spinning reserve". We signal this
+                  // by passing -1 as the index of the secondary variable,
+                  // and the level variable index as the primary variable.
+                  this.code.push([VMI_update_cash_coefficient, [
+                      VM.PRODUCE, VM.SPIN_RES, vi, // <-- now as primary
+                      l.flow_delay, -1, // <-- signal that it is "REM_CAP"
+                      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
@@ -4035,6 +4049,12 @@ class VirtualMachine {
                 // NOTE: no delay on this type of link
                 this.code.push([VMI_add_peak_increase_at_t_0,
                     [vi, l.relative_rate]]);
+              } else if(l.multiplier === VM.LM_AVAILABLE_CAPACITY) {
+                // The "available capacity" equals UB - level, so subtract
+                // UB * rate from RHS, while considering the delay.
+                // NOTE: New instruction style that passes pointers to
+                // model entities instead of their properties.
+                this.code.push([VMI_add_available_capacity, l]);
               } else if(l.relative_rate.isStatic) {
                 // Static rates permit simpler VM instructions
                 c = l.relative_rate.result(0);
@@ -4311,7 +4331,7 @@ class VirtualMachine {
                 hub = ub;
             if(ub > VM.MEGA_UPPER_BOUND) {
               hub = p.highestUpperBound([]);
-              // If UB still very high, warn modeler on infoline and in monitor
+              // If UB still very high, warn modeler on infoline and in monitor.
               if(hub > VM.MEGA_UPPER_BOUND) {
                 const msg = 'High upper bound (' + this.sig4Dig(hub) +
                     ') for <strong>' + p.displayName + '</strong>' +
@@ -5005,6 +5025,8 @@ class VirtualMachine {
         } else if(l.multiplier === VM.LM_SHUTDOWN) {
           // Similar to STARTUP, but now look in the shut-down list.
           pl = (p.shut_downs.indexOf(bt) < 0 ? 0 : 1);
+        } else if(l.multiplier === VM.LM_AVAILABLE_CAPACITY) {
+          pl = p.upper_bound.result(bt) - pl;
         } else if(l.multiplier === VM.LM_INCREASE) {
           const ppl = p.actualLevel(bt - 1);
           pl = this.severestIssue([pl, ppl], pl - ppl);
@@ -6423,6 +6445,8 @@ Solver status = ${json.status}`);
       this.MINUS_INFINITY = this.SOLVER_MINUS_INFINITY;
       console.log('DIAGNOSIS OFF');
     }
+    this.NEAR_PLUS_INFINITY = this.PLUS_INFINITY / 200;
+    this.NEAR_MINUS_INFINITY = this.MINUS_INFINITY / 200;
     // The "propt to diagnose" flag is set when some block posed an
     // infeasible or unbounded problem.
     this.prompt_to_diagnose = false;
@@ -8538,9 +8562,12 @@ function VMI_update_cash_coefficient(args) {
     // 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).
+    // NOTE: This type is also used to compute "available capacity".
     const
-        plvi = args[4],
-        // NOTE: Column of second variable will be relative to same offset.
+        // args[4] = -1 signals that the remaining capacity should be
+        // computed, which means that ON/OFF should be disregarded.
+        plvi = (args[4] < 0 ? vi : args[4]),
+        // 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);
@@ -9198,6 +9225,44 @@ function VMI_add_peak_increase_at_t_0(args) {
   // series of coefficient-setting instructions
 }
 
+function VMI_add_available_capacity(link) {
+  // Adds the "available capacity" of the FROM node (process) to the
+  // level of the TO node (data product) while considering the delay.
+  // NOTE: New instruction style that passes pointers to model entities
+  // instead of their properties.
+  const
+      d = link.actualDelay(VM.t),
+      fnvi = link.from_node.level_var_index,
+      // Column number in the tableau.
+      fnk = VM.offset + fnvi - d * VM.cols,
+      // Use flow rate and upper bound for t minus delay.
+      t = VM.t - d,
+      r = link.relative_rate.result(t),
+      u = link.from_node.upper_bound.result(t);
+  if(DEBUGGING) {
+    console.log('VMI_add_available_capacity (t = ' + VM.t + ')',
+        link.displayName, 'UB', u, 'rate', r);
+  }
+  // Available capacity equals UB - level, so subtract UB * rate
+  // from RHS...
+  VM.rhs -= u * r;
+  // ... and subtract rate from FROM node coefficient. 
+  if(fnk <= 0) {
+    // NOTE: If `fnk` falls PRIOR to the start of the block being solved,
+    // this means that the value of the decision variable X for which the
+    // coefficient C is to be set by this instruction has been calculated
+    // while solving a previous block. Since the value of X is known,
+    // adding X*rate to C is implemented as subtracting X*rate from the
+    // right hand side of the constraint.
+    VM.rhs += knownValue(fnvi, t) * r;
+  } else if(fnk in VM.coefficients) {
+    VM.coefficients[fnk] -= r;
+  } else {
+    VM.coefficients[fnk] = -r;
+  }
+}
+
+
 // NOTE: the global constants below are not defined in linny-r-globals.js
 // because some comprise the identifiers of functions for VM instructions