linny-r 3.0.7 → 3.0.8

package/package.json

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

package/static/scripts/linny-r-gui-file-manager.js

@@ -314,10 +314,10 @@ class GUIFileManager {
       const mi = this.model_index;
       if(mi >= 0) {
         path += this.separator;
-        if(mi < sd.sdcount) {
+        if(mi < this.sd_count) {
           path += sd.subdirs[mi].name;
         } else {
-          path += sd.models[mi - sd.sdcount].name + '.lnr';
+          path += sd.models[mi - this.sd_count].name + '.lnr';
           this.new_window_btn.title =
               'Open selected model in new Linny-R tab in browser';
         }
@@ -1260,7 +1260,7 @@ class GUIFileManager {
       const
           mi = this.model_index,
           sd = this.selected_dir;
-      if(mi >= sd.sdcount) {
+      if(mi >= this.sd_count) {
         const mdl = sd.models[mi - this.sd_count];
         if(mdl) {
           window.localStorage.setItem('linny-r-model-file',

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

@@ -167,6 +167,8 @@ class Finder {
         enl = [],
         et = this.entity_types,
         fp = this.filter_pattern && this.filter_pattern.length > 0;
+    // Position "orphan" products (if any) in focal cluster and notify modeler.
+    MODEL.revealOrphans();
     let imgs = '';
     this.entities.length = 0;
     this.filtered_types.length = 0;

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

@@ -1102,6 +1102,8 @@ class LinnyRModel {
   canLink(from, to) {
     // Return TRUE iff FROM-node can feature a "straight" link (i.e., a
     // product flow) to TO-node.
+    // FROM and TO *must* be different nodes.
+    if(from === to) return false;
     if(from.type === to.type) {
       // No "straight" link between nodes of same type (see canConstrain
       // for "curved" links) UNLESS TO-node is a data product.
@@ -1135,6 +1137,37 @@ class LinnyRModel {
     return this.end_period - this.start_period + 1 + this.look_ahead;
   }
   
+  revealOrphans() {
+    // Find all products that are *not* positioned in some cluster,
+    // position them in the focal cluster, and notify the user.
+    const orphans = [];
+    for(const k in this.products) if(this.products.hasOwnProperty(k)) {
+      const p = this.products[k];
+      if(p.isOrphan) orphans.push(p);
+    }
+    if(orphans.length) {
+      let x = 100,
+          y = 70,
+          n = 0;
+      const fc = this.focal_cluster;
+      for(const p of orphans) {
+        const pp = fc.addProductPosition(p, x, y);
+        if(pp) {
+          x += 90;
+          y += 45;
+          n++;
+        }
+      }
+      // Prepare focal cluster for redrawing.
+      fc.clearAllProcesses();
+      // Select the added product positions and redraw.
+      this.selectList(orphans);
+      UI.drawDiagram(this);
+      // Finally, notify the modeler.
+      UI.warn(pluralS(n, '"orphaned" product') + ' added to the focal cluster');
+    }
+  }
+  
   processSelectorList(sl) {
     // Check whether selector list `sl` constitutes a new dimension.
     // Ignore lists of fewer than 2 "plain" selectors.
@@ -1675,6 +1708,12 @@ class LinnyRModel {
       if(node) l.initFromXML(node);
       return l;
     }
+    // FROM and TO nodes must be different. The UI should not permit
+    // drawing such nodes, but check nonetheless.
+    if(from === to) {
+      UI.warn(`${from.type} "${from.displayName}" cannot be linked to itself`);
+      return null;
+    }
     l = new Link(from, to);
     if(node) l.initFromXML(node);
     this.links[l.identifier] = l;
@@ -1705,6 +1744,12 @@ class LinnyRModel {
       if(node) c.initFromXML(node);
       return c;
     }
+    // FROM and TO nodes must be different. The UI should not permit
+    // drawing such nodes, but check nonetheless.
+    if(from === to) {
+      UI.warn(`${from.type} "${from.displayName}" cannot constrain itself`);
+      return null;
+    }
     c = new Constraint(from, to);
     if(node) c.initFromXML(node);
     // New constraint => prepare for redraw.
@@ -2829,15 +2874,12 @@ class LinnyRModel {
   updateChartVariables(e) {
     // Ensure that all chart variable names based on entity `e` will be
     // displayed correctly the next time they are drawn.
-console.log('HERE e', e.displayName);
     const sc = this.charts[CHART_MANAGER.chart_index];
     let ucm = false;
     for(const c of this.charts) {
       for(const v of c.variables) {
-        console.log('HERE v', v.displayName);
         if(v.object === e) {
           v.display_name = '';
-          console.log('HERE v new', v.displayName);
           ucm = ucm || c === sc;
         }
       }
@@ -8826,6 +8868,11 @@ class Product extends Node {
     return ppc;
   }
   
+  get isOrphan() {
+    // Return TRUE if this product has no position in any cluster.
+    return this.productPositionClusters.length <= 0;
+  }
+  
   get toBeBlackBoxed() {
     // Return TRUE if this product occurs only in "black box" clusters.
     for(const c of this.productPositionClusters) if(!c.blackBoxed) return false;

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

@@ -173,9 +173,6 @@ class Expression {
     this.wildcard_vectors = {};
     this.wildcard_vector_index = false;
     this.method_object_list.length = 0;
-    if(!isEmpty(this.cache)) {
-      console.log('HERE Clearing cache', this.text, '\n', Object.keys(this.cache));
-    }
     this.cache = {};
     this.compile(); // if(!this.compiled)  REMOVED to ensure correct isStatic!! 
     // Static expressions only need a vector with one element (having index 0)
@@ -1223,26 +1220,24 @@ class ExpressionParser {
       if(!anchor1) anchor1 = 't';
       if(!anchor2) anchor2 = 't';
     }
-    // First handle this special case: no name or attribute. This is valid
-    // only for dataset modifier expressions (and hence also equations).
-    // Variables like [@t-1] are interpreted as a self-reference. This is
-    // meaningful when a *negative* offset is specified to denote "use the
-    // value of this expression for some earlier time step".
-    // NOTES:
-    // (1) This makes the expression dynamic.
-    // (2) It does not apply to array-type datasets, as these have no
-    //     time dimension.
-    if(!name && !attr && this.dataset && !this.dataset.array) {
+    // First handle this special case: an equation self-reference.
+    // Variables like [@t-1] are interpreted as an implicit self-reference.
+    // Self-references are meaningful when a *negative* offset is specified
+    // to denote "use the value of this expression for some earlier time step".
+    // NOTE: This makes the expression dynamic.
+    if(!attr && this.dataset === MODEL.equations_dataset &&
+        (!name || UI.nameToID(name) === UI.nameToID(this.attribute))) {
       this.is_static = false;
       this.log('dynamic because of self-reference');
-      if(('cips'.indexOf(anchor1) >= 0 || anchor1 === 't' && offset1 < 0) &&
-          ('cips'.indexOf(anchor2) >= 0 ||anchor2 === 't' && offset2 < 0)) {
+      if(('cfps'.indexOf(anchor1) >= 0 || anchor1 === 't' && offset1 < 0) &&
+          ('cfps'.indexOf(anchor2) >= 0 ||anchor2 === 't' && offset2 < 0)) {
         if(this.TRACE) console.log('TRACE: Variable is a self-reference.');
         // The `xv` attribute will be recognized by VMI_push_var to denote
         // "use the vector of the expression for which this VMI is code".
-        return [{xv: true, dv: this.dataset.defaultValue},
+        return [{xv: true, dv: VM.UNDEFINED},
             anchor1, offset1, anchor2, offset2];
       }
+      // Fall-through: invalid offset => warning.
       msg = 'Expression can reference only previous values of itself';
     }
     // A leading "!" denotes: pass variable reference instead of its value.
@@ -1531,8 +1526,12 @@ class ExpressionParser {
       let sel = '',
           xtype = '';
       if(obj instanceof DatasetModifier) {
-        sel = obj.selector;
-        xtype = 'Equation';
+        if(attr) {
+          msg = 'Equations have no attributes';
+        } else {
+          sel = obj.selector;
+          xtype = 'Equation';
+        }
       } else if(obj instanceof Dataset) {
         sel = attr;
         xtype = 'Dataset modifier expression';
@@ -3394,7 +3393,7 @@ class VirtualMachine {
       // If not a sink, UB is set to 0.
       if(notsnk) u = 0;
     }
-    
+
     // NOTE: Stock constraints must take into account extra inflows
     // (source) or outflows (sink).
     // Check for special case of equal bounds, as then one EQ constraint
@@ -3434,7 +3433,7 @@ class VirtualMachine {
         this.code.push(
           [l instanceof Expression? VMI_set_var_rhs : VMI_set_const_rhs, l],
           [VMI_add_constraint, VM.GE]
-        );          
+        );
       }
       // Add upper bound (LE) constraint unless product is a sink node
       if(notsnk) {
@@ -3448,7 +3447,7 @@ class VirtualMachine {
         this.code.push(
           [u instanceof Expression ? VMI_set_var_rhs : VMI_set_const_rhs, u],
           [VMI_add_constraint, VM.LE]
-        );          
+        );
       }
     }
   }
@@ -5079,7 +5078,7 @@ class VirtualMachine {
         MODEL.calculateCostPrices(b);
       }
     }
-
+/*
     // THEN: Reset all datasets that are outcomes or serve as "formulas".
     for(let k in MODEL.datasets) if(MODEL.datasets.hasOwnProperty(k)) {
       const ds = MODEL.datasets[k];
@@ -5092,7 +5091,7 @@ class VirtualMachine {
         }
       }
     }
-
+*/
     // THEN: Reset the vectors of all chart variables.
     for(const c of MODEL.charts) c.resetVectors();
     
@@ -6743,7 +6742,12 @@ function VMI_push_var(x, args) {
     x.push(v);
   } else if(xv) {
     // Variable references an earlier value computed for this expression `x`.
-    x.push(t >= 0 && t < x.vector.length ? x.vector[t] : obj.dv);
+    // NOTE: When this value has NOT been computed yet, use the specified default.
+    if(t >= 0 && t < x.vector.length && x.vector[t] !== VM.NOT_COMPUTED) {
+      x.push(x.vector[t]);
+    } else {
+      x.push(obj.dv);
+    }
   } else if(obj.hasOwnProperty('c') && obj.hasOwnProperty('u')) {
     // Object holds link lists for cluster balance computation.
     x.push(MODEL.flowBalance(obj, t));
@@ -8375,7 +8379,7 @@ function VMI_set_bounds(args) {
       VM.variables[vi - 1][0],'] t = ', VM.t, ' LB = ', VM.sig4Dig(l),
       ', UB = ', VM.sig4Dig(u), fixed].join(''), l, u, inf_val, 'args:', args);
     console.log(p);
-    throw "STOP";
+    if(!DEBUGGING) throw "STOP";
   } else if(u < l) {
     // Check the difference, as this may be negligible.
     if(u - l < VM.SIG_DIF_FROM_ZERO) {
@@ -9075,6 +9079,8 @@ function VMI_update_grid_process_cash_coefficients(p) {
   // VMI_update_cash_coefficient).
   let fn = null,
       tn = null;
+  // NOTE: Grid processes are assumed to connect exactly *two* products by
+  // regular links, so it suffices to find the *first* ingoing...
   for(const l of p.inputs) {
     if(l.multiplier === VM.LM_LEVEL &&
         !MODEL.ignored_entities[l.identifier]) {
@@ -9082,6 +9088,7 @@ function VMI_update_grid_process_cash_coefficients(p) {
       break;
     }
   }
+  // ... and the first outgoing regular link.
   for(const l of p.outputs) {
     if(l.multiplier === VM.LM_LEVEL &&
         !MODEL.ignored_entities[l.identifier]) {
@@ -9092,7 +9099,7 @@ function VMI_update_grid_process_cash_coefficients(p) {
   const
       fp = (fn && fn.price.defined ? fn.price.result(VM.t) : 0),
       tp = (tn && tn.price.defined ? tn.price.result(VM.t) : 0);
-  // Only proceed if process links to a product with a non-zero price.
+  // Only proceed if process links to at least one product with a non-zero price.
   if(fp || tp) {
     const
         gpv = VM.gridProcessVarIndices(p, VM.offset),
@@ -9101,30 +9108,30 @@ function VMI_update_grid_process_cash_coefficients(p) {
       // If FROM node has price > 0, then all UP flows generate cash OUT
       // *without* loss while all DOWN flows generate cash IN *with* loss.
       for(let i = 0; i < gpv.slopes; i++) {
-        addCashOut(gpv.up[i], -fp);
-        addCashIn(gpv.down[i], (1 - lr[i]) * -fp);
+        addCashOut(gpv.up[i], fp);
+        addCashIn(gpv.down[i], (1 - lr[i]) * fp);
       }
     } else if(fp < 0) {
       // If FROM node has price < 0, then all UP flows generate cash IN
       // *without* loss while all DOWN flows generate cash OUT *with* loss.
       for(let i = 0; i < gpv.slopes; i++) {
-        addCashIn(gpv.up[i], fp);
-        addCashOut(gpv.down[i], (1 - lr[i]) * fp);
+        addCashIn(gpv.up[i], -fp);
+        addCashOut(gpv.down[i], (1 - lr[i]) * -fp);
       }
     }
     if(tp > 0) {    
       // If TO node has price > 0, then all UP flows generate cash IN *with*
       // loss while all DOWN flows generate cash OUT *without* loss.
       for(let i = 0; i < gpv.slopes; i++) {
-        addCashIn(gpv.up[i], (1 - lr[i]) * -tp);
-        addCashOut(gpv.down[i], -tp);
+        addCashIn(gpv.up[i], (1 - lr[i]) * tp);
+        addCashOut(gpv.down[i], tp);
       }
     } else if(tp < 0) {
       // If TO node has price < 0, then all UP flows generate cash OUT
       // *with* loss while all DOWN flows generate cash IN *without* loss.
       for(let i = 0; i < gpv.slopes; i++) {
-        addCashOut(gpv.up[i], (1 - lr[i]) * tp);
-        addCashIn(gpv.down[i], tp);
+        addCashOut(gpv.up[i], (1 - lr[i]) * -tp);
+        addCashIn(gpv.down[i], -tp);
       }
     }
   }
@@ -9179,15 +9186,14 @@ function VMI_add_constraint(ct) {
   for(let i in VM.coefficients) if(Number(i)) {
     // Do not add (near)zero coefficients to the matrix.
     const c = VM.coefficients[i];
-    if(Math.abs(c) >= VM.NEAR_ZERO) {
-      row[i] = c;
-    }
+    if(Math.abs(c) >= VM.NEAR_ZERO) row[i] = c;
   }
   // Special case: 
   if(ct === VM.ACTOR_CASH) {
     VM.actor_cash_constraints.push(VM.matrix.length);
     ct = VM.EQ;
   }
+
   let rhs = VM.rhs;
   // Check for <= (near) +infinity and >= (near) -infinity: such
   // constraints should not be added to the model.