linny-r 2.1.6 → 2.1.7

package/package.json

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

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

@@ -11,7 +11,7 @@ warning or information messages are displayed.
 */
 
 /*
-Copyright (c) 2017-2024 Delft University of Technology
+Copyright (c) 2017-2025 Delft University of Technology
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -41,7 +41,7 @@ const CONFIGURATION = {
     // To keep model files compact, floating point values in datasets and run
     // results are stored with a limited number of significant digits
     dataset_precision: 8,
-    results_precision: 6,
+    results_precision: 8,
     // Default properties for new models
     default_currency_unit: 'EUR',
     default_time_unit: 'hour',

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

@@ -90,7 +90,8 @@ class GUIFileManager {
               if(!UI.hidden('series-modal')) {
                 DATASET_MANAGER.series_data.value = data.split(';').join('\n');
               } else {
-                dataset.unpackDataString(data);
+                // NOTE: FALSE indicates that data is *not* B62-encoded.
+                dataset.unpackDataString(data, false);
               }
             }
             // NOTE: remove dataset from the "loading" list

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

@@ -9355,22 +9355,9 @@ class Dataset {
   }
   
   get dataString() {
-    // Data is stored simply as semicolon-separated floating point numbers,
-    // with N-digit precision to keep model files compact (default: N = 8).
-    let d = [];
-    // NOTE: Guard against empty strings and other invalid data.
-    for(const v of this.data) if(v) {
-      try {
-        // Convert number to string with the desired precision.
-        const f = v.toPrecision(CONFIGURATION.dataset_precision);
-        // Then parse it again, so that the number will be represented
-        // (by JavaScript) in the most compact representation.
-        d.push(parseFloat(f));
-      } catch(err) {
-        console.log('-- Notice: dataset', this.displayName, 'has invalid data', v);
-      }
-    }
-    return d.join(';');
+    // NOTE: As of version 2.1.7, data is stored as semicolon-separated
+    // B62-encoded numbers.
+    return packVector(this.data);
   }
   
   get propertiesString() {
@@ -9389,10 +9376,17 @@ class Dataset {
     return ' (' + time_prop + (this.periodic ? ' \u21BB' : '') + ')'; 
   }
   
-  unpackDataString(str) {
+  unpackDataString(str, b62=true) {
     // Convert semicolon-separated data to a numeric array.
+    // NOTE: When b62 is FALSE, data is not B62-encoded.
     this.data.length = 0;
-    if(str) for(const n of str.split(';')) this.data.push(parseFloat(n));
+    if(str) {
+      if(b62) {
+        this.data = unpackVector(str);
+      } else {
+        for(const n of str.split(';')) this.data.push(parseFloat(n));
+      }
+    }
     this.computeVector();
     this.computeStatistics();
   }
@@ -9611,24 +9605,31 @@ class Dataset {
       n = MODEL.black_box_entities[id];
       cmnts = '';
     }
-    const xml = ['<dataset', p, '><name>', xmlEncoded(n),
-        '</name><notes>', cmnts,
-        '</notes><default>', this.default_value,
-        '</default><unit>', xmlEncoded(this.scale_unit),
-        '</unit><time-scale>', this.time_scale,
-        '</time-scale><time-unit>', this.time_unit,
-        '</time-unit><method>', this.method,
-        '</method><url>', xmlEncoded(this.url),
-        '</url><data>', xmlEncoded(this.dataString),
-        '</data><modifiers>', ml.join(''),
-        '</modifiers><default-selector>', xmlEncoded(this.default_selector),
-        '</default-selector></dataset>'].join('');
-    return xml;
+    const
+        data = xmlEncoded(this.dataString),
+        xml = ['<dataset', p, '>',
+            '<name>', xmlEncoded(n),
+            '</name><unit>', xmlEncoded(this.scale_unit),
+            '</unit><time-scale>', this.time_scale,
+            '</time-scale><time-unit>', this.time_unit,
+            '</time-unit><method>', this.method,
+            '</method>'];
+    // NOTE: Omit empty fields to reduce model file size.
+    if(cmnts) xml.push('<notes>', cmnts, '</notes>');
+    if(this.default_value) xml.push('<default>',
+        this.default_value, '</default>');
+    if(this.url) xml.push('<url>', xmlEncoded(this.url), '</url>');
+    if(data) xml.push('<data b62="1">', data, '</data>');
+    if(ml.length) xml.push('<modifiers>', ml.join(''), '</modifiers>');
+    if(this.default_selector) xml.push('<default-selector>',
+        xmlEncoded(this.default_selector), '</default-selector>');
+    xml.push('</dataset>');
+    return xml.join('');
   }
 
   initFromXML(node) {
     this.comments = xmlDecoded(nodeContentByTag(node, 'notes'));
-    this.default_value = safeStrToFloat(nodeContentByTag(node, 'default'));
+    this.default_value = safeStrToFloat(nodeContentByTag(node, 'default'), 0);
     this.scale_unit = xmlDecoded(nodeContentByTag(node, 'unit')) || '1';
     this.time_scale = safeStrToFloat(nodeContentByTag(node, 'time-scale'), 1);
     this.time_unit = nodeContentByTag(node, 'time-unit') ||
@@ -9643,7 +9644,14 @@ class Dataset {
     if(this.url) {
       FILE_MANAGER.getRemoteData(this, this.url);
     } else {
-      this.unpackDataString(xmlDecoded(nodeContentByTag(node, 'data')));
+      let data = '',
+          b62 = false;
+      const cn = childNodeByTag(node, 'data');
+      if(cn) {
+        data = nodeContent(cn);
+        b62 = (nodeParameterValue(cn, 'b62') === '1');
+      }
+      this.unpackDataString(xmlDecoded(data), b62);
     }
     const n = childNodeByTag(node, 'modifiers');
     if(n) {
@@ -11372,83 +11380,30 @@ class ExperimentRunResult {
     return (this.attribute ? dn + '|' + this.attribute : dn);
   }
 
-  get vectorString() {
-    // Vector is coded as semicolon-separated floating point numbers
-    // reduced to N-digit precision to keep model files more compact.
-    // By default, N = 6; this can be altered in linny-r-config.js.
-    // To represent "sparse" vectors more compactly, sequences of
-    // identical values are encoded as NxF where N is the length of
-    // the sequence and F the numerical value, e.g., "17x0.4;0.2;7x0"
-    if(this.was_ignored) return '';
-    let prev = '',
-        cnt = 1;
-    const vl = [];
-    for(const v of this.vector) {
-      // Format number with desired precision.
-      const f = v.toPrecision(CONFIGURATION.results_precision);
-      // While value is same as previous, do not store, but count.
-      if(f === prev) {
-        cnt++;
-      } else {
-        if(cnt > 1) {
-          // More than one => "compress".
-          // NOTE: Parse so JavaScript will represent it most compactly.
-          vl.push(cnt + 'x' + parseFloat(prev));
-          cnt = 1;
-        } else if(prev) {
-          vl.push(parseFloat(prev));
-        }
-        prev = f;
-      }
-    }
-    // Add the last "batch" of numbers.
-    if(cnt > 1) {
-      // More than one => "compress".
-      // NOTE: Parse so JavaScript will represent it most compactly.
-      vl.push(cnt + 'x' + parseFloat(prev));
-      cnt = 1;
-    } else if(prev) {
-      vl.push(parseFloat(prev));
-    }
-    return vl.join(';');
-  }
-  
-  unpackVectorString(str) {
-    // Convert semicolon-separated data to a numeric array.
-    this.vector = [];
-    if(str && !this.was_ignored) {
-      for(const parts of str.split(';')) {
-        const tuple = parts.split('x');
-        if(tuple.length === 2) {
-          const
-              n = parseInt(tuple[0]),
-              f = parseFloat(tuple[1]);
-          for(let i = 0; i < n; i++) {
-            this.vector.push(f);
-          }
-        } else {
-          this.vector.push(parseFloat(tuple[0]));
-        }
-      }
-    }
-  }
-
   get asXML() {
-    return ['<run-result', (this.x_variable ? ' x-variable="1"' : ''),
-      (this.was_ignored ? ' ignored="1"' : ''),
-      '><object-id>', xmlEncoded(this.object_id),
-      '</object-id><attribute>', xmlEncoded(this.attribute),
-      '</attribute><count>', this.N,
-      '</count><sum>', this.sum,
-      '</sum><mean>', this.mean,
-      '</mean><variance>', this.variance,
-      '</variance><minimum>', this.minimum,
-      '</minimum><maximum>', this.maximum,
-      '</maximum><non-zero-tally>', this.non_zero_tally,
-      '</non-zero-tally><last>', this.last,
-      '</last><exceptions>', this.exceptions,
-      '</exceptions><vector>', this.vectorString,
-      '</vector></run-result>'].join('');
+    const
+        data = (this.was_ignored ? '' : packVector(this.vector)),
+        xml = ['<run-result',
+            (this.x_variable ? ' x-variable="1"' : ''),
+            (this.was_ignored ? ' ignored="1"' : ''),
+            '><object-id>', xmlEncoded(this.object_id),
+            '</object-id><attribute>', xmlEncoded(this.attribute),
+            '</attribute>'];
+    // NOTE: Reduce model size by saving only non-zero statistics.
+    if(this.N) xml.push('<count>', this.N, '</count>');
+    if(this.sum) xml.push('<sum>', this.sum, '</sum>');
+    if(this.mean) xml.push('<mean>', this.mean, '</mean>');
+    if(this.variance) xml.push('<variance>', this.variance, '</variance>');
+    if(this.minimum) xml.push('<minimum>', this.minimum, '</minimum>');
+    if(this.maximum) xml.push('<maximum>', this.maximum, '</maximum>');
+    if(this.non_zero_tally) xml.push('<non-zero-tally>',
+        this.non_zero_tally, '</non-zero-tally>');
+    if(this.last) xml.push('<last>', this.last, '</last>');
+    if(this.exceptions) xml.push('<exceptions>',
+        this.exceptions, '</exceptions>');
+    if(data) xml.push('<vector b62="1">', data, '</vector>');
+    xml.push('</run-result>');
+    return xml.join('');
   }
 
   initFromXML(node) {
@@ -11461,16 +11416,22 @@ class ExperimentRunResult {
     if(this.object_id === UI.EQUATIONS_DATASET_ID &&
         !earlierVersion(MODEL.version, '1.3.0')) attr = xmlDecoded(attr);
     this.attribute = attr;
-    this.N = safeStrToInt(nodeContentByTag(node, 'count'));
-    this.sum = safeStrToFloat(nodeContentByTag(node, 'sum'));
-    this.mean = safeStrToFloat(nodeContentByTag(node, 'mean'));
-    this.variance = safeStrToFloat(nodeContentByTag(node, 'variance'));
-    this.minimum = safeStrToFloat(nodeContentByTag(node, 'minimum'));
-    this.maximum = safeStrToFloat(nodeContentByTag(node, 'maximum'));
-    this.non_zero_tally = safeStrToInt(nodeContentByTag(node, 'non-zero-tally'));
-    this.last = safeStrToInt(nodeContentByTag(node, 'last'));
-    this.exceptions = safeStrToInt(nodeContentByTag(node, 'exceptions'));
-    this.unpackVectorString(nodeContentByTag(node, 'vector'));
+    this.N = safeStrToInt(nodeContentByTag(node, 'count'), 0);
+    this.sum = safeStrToFloat(nodeContentByTag(node, 'sum'), 0);
+    this.mean = safeStrToFloat(nodeContentByTag(node, 'mean'), 0);
+    this.variance = safeStrToFloat(nodeContentByTag(node, 'variance'), 0);
+    this.minimum = safeStrToFloat(nodeContentByTag(node, 'minimum'), 0);
+    this.maximum = safeStrToFloat(nodeContentByTag(node, 'maximum'), 0);
+    this.non_zero_tally = safeStrToInt(nodeContentByTag(node, 'non-zero-tally'), 0);
+    this.last = safeStrToFloat(nodeContentByTag(node, 'last'), 0);
+    this.exceptions = safeStrToInt(nodeContentByTag(node, 'exceptions'), 0);
+    const cn = childNodeByTag(node, 'vector');
+    if(cn && !this.was_ignored) {
+      const b62 = nodeParameterValue(cn, 'b62') === '1';
+      this.vector = unpackVector(nodeContent(cn), b62);
+    } else {
+      this.vector = [];
+    }
   }
   
   valueAtModelTime(t, mtsd, method, periodic) {
@@ -11597,7 +11558,7 @@ class ExperimentRun {
       UI.warn(`Run title "${t}" does not match experiment title "` +
           this.experiment.title + '"');
     }
-    this.combi = nodeContentByTag(node, 'x-combi').split(' ');
+    this.combination = nodeContentByTag(node, 'x-combi').split(' ');
     this.time_steps = safeStrToInt(nodeContentByTag(node, 'time-steps'));
     this.time_step_duration = safeStrToFloat(nodeContentByTag(node, 'delta-t'));
     let n = childNodeByTag(node, 'results');

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

@@ -53,6 +53,174 @@ function postData(obj) {
 // Functions that convert numbers to strings, or strings to numbers
 //
 
+const b62 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+function posIntToB62(n) {
+  // Return the radix-62 encoding of positive integer value `n`.
+  let s = '';
+  while(n > 0) {
+    s = b62.charAt(n % 62) + s;
+    n = Math.floor(n / 62);
+  }
+  return s;
+}
+
+function B62ToInt(s) {
+  // Return the value of a B62-encoded integer, or -1 if `s` contains an
+  // invalid character.
+  const digits = s.split('');
+  let n = 0;
+  for(const d of digits) {
+    const index = b62.indexOf(d);
+    if(index < 0) return -1;
+    n = n * 62 + index;
+  }
+  return n;
+}
+
+function packFloat(f) {
+  // Return floating point number `f` in a compact string notation.
+  // The first character encodes whether `f` is an integer (then no exponent),
+  // whether the sign of `f` is + or -, and whether the sign of the exponent
+  // (if any) is + or - in the following manner:
+  //      (no leading special character) => positive integer (no exponent)
+  //   -  negative integer (no exponent)
+  //   ^  positive number, positive exponent
+  //   _  negative number, positive exponent
+  //   ~  positive number, negative exponent
+  //   =  negative number, negative exponent
+const oldf = f;
+  if(!f) return '0';
+  let sign = '',
+      mant = '',
+      exp = 0;
+  if(f < 0.0) {
+    sign = '-';
+    f = -f;
+  }
+  const rf = Math.round(f);
+  // When number is integer, it has no exponent part.
+  if(rf === f) return sign + posIntToB62(rf);
+  const me = f.toExponential().split('e');
+  // Remove the decimal period from the mantissa.
+  mant = posIntToB62(parseInt(me[0].replace('.', '')));
+  // Determine the exponent part and its sign.
+  exp = parseInt(me[1]);
+  if(exp < 0) {
+    exp = -exp;
+    sign = (sign ? '=' : '~');
+  } else {
+    sign = (sign ? '_' : '^');
+  }
+  // NOTE: Exponent is always codes as a single character. This limits
+  // its value to 61, which for Linny-R suffices to code even its error
+  // values (highest error code exponent is +50).
+  return sign + mant + (exp ? posIntToB62(Math.min(exp, 61)) : '0');
+}
+
+function unpackFloat(s) {
+  // Return the number X that was encoded using packFloat(X).
+  // NOTE: When decoding fails, -1e+48 is returned to signal #INVALID.
+  if(s === '0') return 0;
+  const
+      INVALID = -1e+48,
+      ss = s.split('');
+  const index = '-^_~='.indexOf(ss[0]);
+  if(index < 1) {
+    // No exponent => get the absolute integer value.
+    const n = B62ToInt(s.substring(index + 1));
+    if(n < 0) return INVALID;
+    // Return the signed integer value.
+    return (index ? n : -n);
+  }
+  // Now the last character codes the exponent.
+  const
+      // Odd index (1 and 3) indicates positive number.
+      sign = (index % 2 ? '' : '-'),
+      // Low index (1 and 2) indicates positive exponent.
+      esign = (index < 3 ? 'e+' : 'e-');
+  // Remove the sign character.
+  ss.shift();
+  // Get and remove the exponent character, and decode it.
+  let exp = B62ToInt(ss.pop());
+  if(exp < 0) return INVALID; 
+  exp = esign + exp.toString();
+  let mant = B62ToInt(ss.join(''));
+  if(mant < 0) return INVALID;
+  mant = mant.toString();
+  // NOTE: No decimal point if mantissa is a single decimal digit.
+  if(mant.length > 1) mant = mant.slice(0, 1) + '.' + mant.slice(1);
+  return parseFloat(sign + mant + exp);
+}
+
+function packVector(vector) {
+  // Vector is coded as semicolon-separated B62-encoded floating
+  // point numbers (no precision loss).
+  // To represent "sparse" vectors more compactly, sequences of
+  // identical values are encoded as N*F where N is the length of
+  // the sequence and F the B62-encoded numerical value.
+  let prev = false,
+      cnt = 0;
+  const vl = [];
+  for(const v of vector) {
+    // While value is same as previous, do not store, but count.
+    // NOTE: JavaScript precision is about 15 decimals, so test for
+    // equality with this precision.
+    if(prev === false || Math.abs(v - prev) < 0.5e-14) {
+      cnt++;
+    } else {
+      const b62 = packFloat(prev);
+      if(cnt > 1) {
+        // More than one => "compress".
+        vl.push(cnt + '*' + b62);
+        cnt = 1;
+      } else {
+        vl.push(b62);
+      }
+    }
+    prev = v;
+  }
+  if(cnt) {
+    const b62 = packFloat(prev);
+    // Add the last "batch" of numbers.
+    if(cnt > 1) {
+      // More than one => "compress".
+      vl.push(cnt + '*' + b62);
+    } else {
+      vl.push(b62);
+    }
+  }
+  return vl.join(';');
+}
+ 
+function unpackVector(str, b62=true) {
+  // Convert semicolon-separated data to a numeric array.
+  // NOTE: Until version 2.1.7, numbers were represented in standard
+  // decimal notation with limited precision. From v2.1.7 onwards, numbers
+  // are B62-encoded. When `b62` is FALSE, the legacy decoding is used.
+  vector = [];
+  if(str) {
+    const
+        ss = str.split(';'),
+        multi = (b62 ? '*' : 'x'),
+        parse = (b62 ? unpackFloat : parseFloat);
+    for(const parts of ss) {
+      const tuple = parts.split(multi);
+      if(tuple.length === 2) {
+        const f = parse(tuple[1]);
+        let n = parseInt(tuple[0]);
+        while(n > 0) {
+          vector.push(f);
+          n--;
+        }
+      } else {
+        vector.push(parse(tuple[0]));
+      }
+    }
+  }
+  return vector;
+}
+
 function pluralS(n, s, special='') {
   // Returns string with noun `s` in singular only if `n` = 1
   // NOTE: third parameter can be used for nouns with irregular plural form
@@ -410,29 +578,29 @@ function patternList(str) {
 
 function patternMatch(str, patterns) {
   // Returns TRUE when `str` matches the &|^-pattern.
-  // NOTE: If a pattern starts with an opening bracket [ then `str` must
-  // start with the rest of the pattern to match. If it ends with a closing
-  // bracket ] then `str` must end with the first part of the pattern.
-  // In this way, [pattern] denotes that `str` should exactly match
+  // NOTE: If a pattern starts with a tilde ~ then `str` must start with
+  // the rest of the pattern to match. If it ends with a tilde, then `str`
+  // must end with the first part of the pattern.
+  // In this way, ~pattern~ denotes that `str` should exactly match.
   for(let i = 0; i < patterns.length; i++) {
     const p = patterns[i];
     // NOTE: `p` is an OR sub-pattern that tests for a set of "plus"
     // sub-sub-patterns (all of which should match) and a set of "min"
     // sub-sub-patters (all should NOT match)
     let pm,
-        swob,
-        ewcb,
+        swt,
+        ewt,
         re,
         match = true;
     for(let j = 0; match && j < p.plus.length; j++) {
       pm = p.plus[j];
-      swob = pm.startsWith('[');
-      ewcb = pm.endsWith(']');
-      if(swob && ewcb) {
+      swt = pm.startsWith('~');
+      ewt = pm.endsWith('~');
+      if(swt && ewt) {
         match = (str === pm.slice(1, -1));
-      } else if(swob) {
+      } else if(swt) {
         match = str.startsWith(pm.substring(1));
-      } else if(ewcb) {
+      } else if(ewt) {
         match = str.endsWith(pm.slice(0, -1));
       } else {
         match = (str.indexOf(pm) >= 0);
@@ -446,8 +614,8 @@ function patternMatch(str, patterns) {
           res[i] = escapeRegex(res[i]);
         }
         res = res.join('(\\d+|\\?\\?)');
-        if(swob) res = '^' + res;
-        if(ewcb) res += '$';
+        if(swt) res = '^' + res;
+        if(ewt) res += '$';
         re = new RegExp(res, 'g');
         match = re.test(str);
       }
@@ -455,13 +623,13 @@ function patternMatch(str, patterns) {
     // Any "min" match indicates NO match for this sub-pattern.
     for(let j = 0; match && j < p.min.length; j++) {
       pm = p.min[j];
-      swob = pm.startsWith('[');
-      ewcb = pm.endsWith(']');
-      if(swob && ewcb) {
+      swt = pm.startsWith('~');
+      ewt = pm.endsWith('~');
+      if(swt && ewt) {
         match = (str !== pm.slice(1, -1));
-      } else if(swob) {
+      } else if(swt) {
         match = !str.startsWith(pm.substring(1));
-      } else if(ewcb) {
+      } else if(ewt) {
         match = !str.endsWith(pm.slice(0, -1));
       } else {
         match = (str.indexOf(pm) < 0);
@@ -474,8 +642,8 @@ function patternMatch(str, patterns) {
           res[i] = escapeRegex(res[i]);
         }
         res = res.join('(\\d+|\\?\\?)');
-        if(swob) res = '^' + res;
-        if(ewcb) res += '$';
+        if(swt) res = '^' + res;
+        if(ewt) res += '$';
         re = new RegExp(res, 'g');
         match = !re.test(str);
       }

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

@@ -7249,14 +7249,14 @@ function VMI_push_run_result(x, args) {
       if(Array.isArray(rn)) {
         // Let the running experiment infer run number from selector list `rn`
         // and its own "active combination" of selectors.
-        rn = xp.matchingCombinationIndex(rn); 
+        rn = xp.matchingCombinationIndex(rn);
       } else if(rn < 0) {
         // Relative run number: use current run # + r (first run has number 0).
         if(xp === MODEL.running_experiment) {
           rn += xp.active_combination_index;
         } else if(xp.chart_combinations.length) {
           // Modeler has selected one or more runs in the viewer table.
-          // FInd the highest number of a selected run that has been performed.
+          // Find the highest number of a selected run that has been performed.
           let last = -1;
           for(const ccn of xp.chart_combinations) {
             if(ccn > last && ccn < xp.runs.length) last = ccn;