linny-r 2.1.5 → 2.1.7

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

@@ -542,7 +542,7 @@ class LinnyRModel {
         e = this.objectByName(en);
     if(!e) return `Unknown model entity "${en}"`;
     const
-        ao = ea[1].split('@'),
+        ao = (ea.length > 1 ? ea[1].split('@') : ['']),
         a = ao[0].trim();
     // Valid if no attribute, as all entity types have a default attribute. 
     if(!a) return true;
@@ -1636,8 +1636,7 @@ class LinnyRModel {
     const ci = this.indexOfChart(title);
     if(ci >= 0) return this.charts[ci];
     // Otherwise, add it. NOTE: Unlike datasets, charts are not "entities".
-    let c = new Chart();
-    c.title = title;
+    let c = new Chart(title);
     if(node) c.initFromXML(node);
     this.charts.push(c);
     // Sort the chart titles alphabetically...
@@ -3323,7 +3322,7 @@ class LinnyRModel {
     vbls.sort((a, b) => UI.compareFullNames(a.displayName, b.displayName));
     // Create a new chart as dummy, so without adding it to this model.
     const
-        c = new Chart(),
+        c = new Chart('__d_u_m_m_y__c_h_a_r_t__'),
         wcdm = [];
     for(const v of vbls) {
       // NOTE: Prevent adding wildcard dataset modifiers more than once.
@@ -6242,19 +6241,19 @@ class Cluster extends NodeBox {
   }
   
   get nestingLevel() {
-    // Return the "depth" of this cluster in the cluster hierarchy
+    // Return the "depth" of this cluster in the cluster hierarchy.
     if(this.cluster) return this.cluster.nestingLevel + 1; // recursion!
     return 0;
   }
   
   get toBeIgnored() {
-    // Return TRUE if this cluster or some parent cluster is set to be ignored
+    // Return TRUE if this cluster or some parent cluster is set to be ignored.
     return this.ignore || MODEL.ignoreClusterInThisRun(this) ||
         (this.cluster && this.cluster.toBeIgnored); // recursion!
   }
   
   get blackBoxed() {
-    // Return TRUE if this cluster or some parent cluster is marked as black box
+    // Return TRUE if this cluster or some parent cluster is marked as black box.
     return this.black_box ||
         (this.cluster && this.cluster.blackBoxed); // recursion!
   }
@@ -7930,6 +7929,7 @@ class Process extends Node {
     const a = {name: this.displayName};
     a.LB = this.lower_bound.asAttribute;
     a.UB = (this.equal_bounds ? a.LB : this.upper_bound.asAttribute);
+    if(this.grid) a.LB = -a.UB;
     a.IL = this.initial_level.asAttribute;
     a.LCF = this.pace_expression.asAttribute;
     if(MODEL.solved) {
@@ -8863,13 +8863,13 @@ class Link {
   }
 
   get identifier() {
-    // NOTE: link IDs are based on the node codes rather than IDs, as this
-    // prevents problems when nodes are renamed
+    // NOTE: Link IDs are based on the node codes rather than IDs, as this
+    // prevents problems when nodes are renamed.
     return this.from_node.code + '___' + this.to_node.code;
   }
 
   get attributes() {
-    // NOTE: link is named by its tab-separated node names
+    // NOTE: Link is named by its tab-separated node names.
     const a = {name: this.from_node.displayName + '\t' + this.to_node.displayName};
     a.R = this.relative_rate.asAttribute;
     if(MODEL.infer_cost_prices) a.SOC = this.share_of_cost;
@@ -9222,7 +9222,7 @@ class Dataset {
   }
   
   get attributes() {
-    // NOTE: modifiers are appended as additional lines of text
+    // NOTE: Modifiers are appended as additional lines of text.
     const a = {name: this.displayName};
     a.D = '\t' + (this.vector ? this.vector[MODEL.t] : this.default_value);
     for(let k in this.modifiers) if(this.modifiers.hasOwnProperty(k)) {
@@ -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) {
@@ -9981,8 +9989,8 @@ class ChartVariable {
       }
       // Scale the value unless run result (these are already scaled!).
       if(!rr) {
-        v *= this.scale_factor;
         if(this.absolute) v = Math.abs(v);
+        v *= this.scale_factor;
       }
       this.vector.push(v);
       // Do not include values for t = 0 in statistics.
@@ -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');
@@ -13051,7 +13012,7 @@ class Constraint {
   }
 
   get typeLetter() {
-    return 'C';
+    return 'B';
   }
 
   get identifier() {

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
@@ -189,11 +357,16 @@ function uniformDecimals(data) {
     }
     maxi = Math.max(maxi, ss[0].length);
   }
-  // STEP 2: Convert the data to a uniform format
+  // STEP 2: Convert the data to a uniform format.
+  const special = ['\u221E', '-\u221E', '\u2047', '\u00A2'];
   for(let i = 0; i < data.length; i++) {
-    const f = parseFloat(data[i]);
+    const
+        v = data[i],
+        f = parseFloat(v);
     if(isNaN(f)) {
-      data[i] = '\u26A0'; // Unicode warning sign
+      // Keep special values such as infinity, and replace error values
+      // by Unicode warning sign.
+      if(special.indexOf(v) < 0) data[i] = '\u26A0'; 
     } else if(maxe > 0) {
     // Convert ALL numbers to exponential notation with two decimals (1.23e+7)
       const v = f.toExponential(2);
@@ -405,51 +578,59 @@ function patternList(str) {
 
 function patternMatch(str, patterns) {
   // Returns TRUE when `str` matches the &|^-pattern.
-  // NOTE: If a pattern starts with equals sign = then `str` must
-  // equal the rest of the pattern to match; if it starts with a tilde
-  // ~ then `str` must start with the rest of the pattern to 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,
+        swt,
+        ewt,
         re,
         match = true;
     for(let j = 0; match && j < p.plus.length; j++) {
       pm = p.plus[j];
-      if(pm.startsWith('=')) {
-        match = (str === pm.substring(1));
-      } else if(pm.startsWith('~')) {
+      swt = pm.startsWith('~');
+      ewt = pm.endsWith('~');
+      if(swt && ewt) {
+        match = (str === pm.slice(1, -1));
+      } else if(swt) {
         match = str.startsWith(pm.substring(1));
+      } else if(ewt) {
+        match = str.endsWith(pm.slice(0, -1));
       } else {
         match = (str.indexOf(pm) >= 0);
       }
-      // If no match, check whether pattern contains wildcards 
+      // If no match, check whether pattern contains wildcards.
       if(!match && pm.indexOf('#') >= 0) {
         // If so, rematch using regular expression that tests for a
-        // number or a ?? wildcard
+        // number or a ?? wildcard.
         let res = pm.split('#');
         for(let i = 0; i < res.length; i++) {
           res[i] = escapeRegex(res[i]);
         }
         res = res.join('(\\d+|\\?\\?)');
-        if(pm.startsWith('=')) {
-          res = '^' + res + '$';
-        } else if(pm.startsWith('~')) {
-          res = '^' + res;
-        }
+        if(swt) res = '^' + res;
+        if(ewt) res += '$';
         re = new RegExp(res, 'g');
         match = re.test(str);
       }
     }
-    // Any "min" match indicates NO match for this sub-pattern,
+    // Any "min" match indicates NO match for this sub-pattern.
     for(let j = 0; match && j < p.min.length; j++) {
       pm = p.min[j];
-      if(pm.startsWith('=')) {
-        match = (str !== pm.substring(1));
-      } else if(pm.startsWith('~')) {
+      swt = pm.startsWith('~');
+      ewt = pm.endsWith('~');
+      if(swt && ewt) {
+        match = (str !== pm.slice(1, -1));
+      } else if(swt) {
         match = !str.startsWith(pm.substring(1));
+      } else if(ewt) {
+        match = !str.endsWith(pm.slice(0, -1));
       } else {
         match = (str.indexOf(pm) < 0);
       }
@@ -461,11 +642,8 @@ function patternMatch(str, patterns) {
           res[i] = escapeRegex(res[i]);
         }
         res = res.join('(\\d+|\\?\\?)');
-        if(pm.startsWith('=')) {
-          res = '^' + res + '$';
-        } else if(pm.startsWith('~')) {
-          res = '^' + res;
-        }
+        if(swt) res = '^' + res;
+        if(ewt) res += '$';
         re = new RegExp(res, 'g');
         match = !re.test(str);
       }
@@ -973,18 +1151,20 @@ function nameToLines(name, actor_name = '') {
   // the node box.
   let m = actor_name.length;
   const
-      d = Math.floor(Math.sqrt(0.3 * name.length)),
+      d = Math.floor(Math.sqrt(0.25 * name.length)),
       // Do not wrap strings shorter than 13 characters (about 50 pixels).
       limit = Math.max(Math.ceil(name.length / d), m, 13),
-      a = name.split(' ');
-  // Split words at '-' when wider than limit
+      // NOTE: Do not split on spaces followed by a number or a single
+      // capital letter.
+      a = name.split(/\s(?!\d+:|\d+$|[A-Z]\W)/);
+  // Split words at '-' when wider than limit.
   for(let j = 0; j < a.length; j++) {
     if(a[j].length > limit) {
       const sw = a[j].split('-');
       if(sw.length > 1) {
-        // Replace j-th word by last fragment of split string
+        // Replace j-th word by last fragment of split string.
         a[j] = sw.pop();
-        // Insert remaining fragments before
+        // Insert remaining fragments before.
         while(sw.length > 0) a.splice(j, 0, sw.pop() + '-');
       }
     }