linny-r 1.9.1 → 1.9.3

package/package.json

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

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

@@ -3471,8 +3471,9 @@ class LinnyRModel {
             let n = 0;
             for(let i = 0; i < constraints.length; i++) {
               const c = constraints[i];
-              if((c.to_node === p && c.soc_direction === VM.SOC_X_Y) ||
-                  (c.from_node === p && c.soc_direction === VM.SOC_Y_X)) n++;
+              if(!MODEL.ignored_entities[c.identifier] &&
+                  ((c.to_node === p && c.soc_direction === VM.SOC_X_Y) ||
+                  (c.from_node === p && c.soc_direction === VM.SOC_Y_X))) n++;
             }
             return n;
           },
@@ -3484,7 +3485,8 @@ class LinnyRModel {
             for(let i = 0; i < p.inputs.length; i++) {
               const l = p.inputs[i];
               // NOTE: Only process --> product links can carry cost.
-              if(l.from_node instanceof Process) {
+              if(!MODEL.ignored_entities[l.identifier] &&
+                  l.from_node instanceof Process) {
                 tuple.n++;
                 if(l.share_of_cost === 0) tuple.nosoc++;
                 const d = l.actualDelay(t);
@@ -3656,12 +3658,15 @@ class LinnyRModel {
         const p = processes[i];
         let cp = 0;
         for(let j = 0; j < p.inputs.length; j++) {
-          const ucp = p.inputs[j].unit_cost_price;
-          if(ucp === VM.UNDEFINED) {
-            cp = VM.UNDEFINED;
-            break;
-          } else {
-            cp += ucp;
+          const l = p.inputs[j];
+          if(!MODEL.ignored_entities[l.identifier]) {
+            const ucp = l.unit_cost_price;
+            if(ucp === VM.UNDEFINED) {
+              cp = VM.UNDEFINED;
+              break;
+            } else {
+              cp += ucp;
+            }
           }
         }
         // NOTE: Also check constraints that transfer cost to `p`.
@@ -3682,31 +3687,33 @@ class LinnyRModel {
           // NOTE: ignore SoC, as this affects the CP of the product, but
           // NOT the CP of the process producing it.
           for(let j = 0; j < p.outputs.length; j++) {
-            const
-                l = p.outputs[j],
-                // NOTE: For output links always use current price.
-                px = l.to_node.price,
-                pr = (px.defined ? px.result(t) : 0),
-                // For levels, consider delay: earlier if delay > 0.
-                dt = t - l.actualDelay(t);
-            if(pr < 0) {
-              // Only consider negative prices.
-              if(l.multiplier === VM.LM_LEVEL) {
-                // Treat links with level multiplier similar to input links,
-                // as this computes CP even when actual level = 0.
-                // NOTE: Subtract (!) so as to ADD the cost.
-                cp -= pr * l.relative_rate.result(dt);
-              } else {
-                // For other types, multiply price by actual flow / level
-                // NOTE: actualFlow already considers delay => use t, not dt.
-                const af = l.actualFlow(t);
-                if(af > VM.NEAR_ZERO) {
-                  // Prevent division by zero.
-                  // NOTE: Level can be zero even if actual flow > 0!
-                  let al = p.nonZeroLevel(dt, l.multiplier);
-                  // NOTE: Scale to level only when level > 1, or fixed
-                  // costs for start-up or first commit will be amplified.
-                  if(al > VM.NEAR_ZERO) cp -= pr * af / Math.max(al, 1);
+            const l = p.outputs[j];
+            if(!MODEL.ignored_entities[l.identifier]) {
+              const
+                  // NOTE: For output links always use current price.
+                  px = l.to_node.price,
+                  pr = (px.defined ? px.result(t) : 0),
+                  // For levels, consider delay: earlier if delay > 0.
+                  dt = t - l.actualDelay(t);
+              if(pr < 0) {
+                // Only consider negative prices.
+                if(l.multiplier === VM.LM_LEVEL) {
+                  // Treat links with level multiplier similar to input links,
+                  // as this computes CP even when actual level = 0.
+                  // NOTE: Subtract (!) so as to ADD the cost.
+                  cp -= pr * l.relative_rate.result(dt);
+                } else {
+                  // For other types, multiply price by actual flow / level
+                  // NOTE: actualFlow already considers delay => use t, not dt.
+                  const af = l.actualFlow(t);
+                  if(af > VM.NEAR_ZERO) {
+                    // Prevent division by zero.
+                    // NOTE: Level can be zero even if actual flow > 0!
+                    let al = p.nonZeroLevel(dt, l.multiplier);
+                    // NOTE: Scale to level only when level > 1, or fixed
+                    // costs for start-up or first commit will be amplified.
+                    if(al > VM.NEAR_ZERO) cp -= pr * af / Math.max(al, 1);
+                  }
                 }
               }
             }
@@ -3767,7 +3774,8 @@ class LinnyRModel {
             cp_sccp = VM.COMPUTING;
         for(let j = 0; j < p.inputs.length; j++) {
           const l = p.inputs[j];
-          if(l.from_node instanceof Process) {
+          if(!MODEL.ignored_entities[l.identifier] &&
+              l.from_node instanceof Process) {
             cp = l.from_node.costPrice(t - l.actualDelay(t));
             if(cp === VM.UNDEFINED && l.share_of_cost > 0) {
               // Contributing CP still unknown => break from FOR loop.

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

@@ -2567,7 +2567,7 @@ class VirtualMachine {
     return Math.round(n);
   }
   
-  sig4Dig(n) {
+  sig4Dig(n, tiny=false) {
     // Return number `n` formatted so as to show 4-5 significant digits.
     // NOTE: As `n` should be a number, a warning sign will typically
     // indicate a bug in the software.
@@ -2576,8 +2576,13 @@ class VirtualMachine {
     // If `n` has a special value, return its representation.
     if(sv[0]) return sv[1];
     const a = Math.abs(n);
+    if(a === 0) return 0;
     // Signal small differences from true 0 by a leading + or - sign.
-    if(n !== 0 && a <= this.ON_OFF_THRESHOLD) return n > 0 ? '+0' : '-0';
+    if(a <= this.ON_OFF_THRESHOLD) {
+      // The `tiny` flag indicates: display small number in E-notation.
+      if(tiny) return n.toPrecision(1);
+      return n > 0 ? '+0' : '-0';
+    }
     if(a >= 9999995) return n.toPrecision(4);
     if(Math.abs(a-Math.round(a)) < 0.0005) return Math.round(n);
     if(a < 1) return Math.round(n*10000) / 10000;
@@ -4666,7 +4671,9 @@ class VirtualMachine {
               }
               if(b <= this.nr_of_time_steps && absl > VM.ON_OFF_THRESHOLD) {
                 this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
-                    `${v[1].displayName} ${v[0]} slack = ${this.sig4Dig(slack)}`);
+                    `${v[1].displayName} ${v[0]} slack = ` +
+                    // NOTE: TRUE denotes "show tiny values with precision".
+                    this.sig4Dig(slack, true));
                 if(v[1] instanceof Product) {
                   const ppc = v[1].productPositionClusters;
                   for(let ci = 0; ci < ppc.length; ci++) {
@@ -6582,28 +6589,32 @@ function relativeTimeStep(t, anchor, offset, dtm, x) {
     // Offset relative to current time step, scaled to time unit of run.
     return Math.floor((t + offset) * dtm);
   }
+  if(anchor === 'f') {
+    // Last: offset relative to index  1 in the vector.
+    return 1 + offset;
+  }
+  if(anchor === 'l') {
+    // Last: offset relative to the last index in the vector.
+    return VM.nr_of_time_steps + offset;
+  }
+  const cb = Math.trunc((t - 1) / MODEL.block_length);
   if(anchor === 'c') {
     // Relative to start of current optimization block.
-    return Math.trunc(t / MODEL.block_length) * MODEL.block_length + offset;
+    return cb * MODEL.block_length + 1 + offset;
   }
   if(anchor === 'p') {
     // Relative to start of previous optimization block.
-    return (Math.trunc(t / MODEL.block_length) - 1) * MODEL.block_length + offset;
+    return (cb - 1) * MODEL.block_length + 1 + offset;
   }
   if(anchor === 'n') {
     // Relative to start of next optimization block.
-    return (Math.trunc(t / MODEL.block_length) + 1) * MODEL.block_length + offset;
-  }
-  if(anchor === 'l') {
-    // Last: offset relative to the last index in the vector.
-    return VM.nr_of_time_steps + offset;
+    return (cb + 1) * MODEL.block_length + 1 + offset;
   }
   if(anchor === 's') {
     // Scaled: offset is scaled to time unit of run.
     return Math.floor(offset * dtm);
   }
   // Fall-through: offset relative to the initial value index (0).
-  // NOTE: this also applies to anchor f (First).
   return offset;
 }
 
@@ -7121,7 +7132,8 @@ function VMI_push_statistic(x, args) {
   t2 = Math.max(0, Math.min(tmax, t2));
   // Trace only now that time step range has been computed
   if(DEBUGGING) {
-    const trc = ['push statistic: [', stat, ': N = ', list.length, ']', ao1, ao2];
+    const trc = ['push statistic: [', stat, ': N = ', list.length, ']',
+        ao1, ao2, ' (t = ', t1, '-', t2, ')'];
     console.log(trc.join(''));
   }
   // Establish whether statistic pertains to non-zero values only
@@ -7157,7 +7169,7 @@ function VMI_push_statistic(x, args) {
   const
       n = vlist.length,
       // NOTE: count is the number of values used in the statistic 
-      count = (nz ? n : list.length);
+      count = (nz ? n : list.length * (t2 - t1 + 1));
   if(stat === 'N') {
     x.push(count);
     return;