linny-r 1.2.0 → 1.3.0

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

@@ -120,6 +120,9 @@ class LinnyRModel {
     // Set the indicator that the model has not been solved yet
     this.set_up = false;
     this.solved = false;
+    // Reset counts of effects of a rename operation
+    this.variable_count = 0;
+    this.expression_count = 0;
   }
   
   // NOTE: a model can also be the entity for the documentation manager,
@@ -557,7 +560,7 @@ class LinnyRModel {
   inferPrefix(obj) {
     // Return the inferred (!) prefixes of `obj` as a list
     if(obj) {
-      const pl = obj.displayName.split(UI.PREFIXER);
+      const pl = UI.prefixesAndName(obj.displayName);
       if(pl.length > 1) {
         pl.pop();
         return pl;
@@ -565,7 +568,7 @@ class LinnyRModel {
     }
     return [];
   }
-
+  
   inferParentCluster(obj) {
     // Find the best "parent" cluster for link or constraint `obj`
     let p, q;
@@ -633,6 +636,14 @@ class LinnyRModel {
     }
     return -1;
   }
+  
+  isDimensionSelector(s) {
+    // Returns TRUE if `s` is a dimension selector in some experiment
+    for(let i = 0; i < this.experiments.length; i++) {
+      if(this.experiments[i].isDimensionSelector(s)) return true;
+    }
+    return false;
+  }
 
   canLink(from, to) {
     // Return TRUE iff FROM-node can feature a "straight" link (i.e., a
@@ -689,8 +700,8 @@ class LinnyRModel {
         // Merge into dimension if there are shared selectors
         for(let i = 0; i < this.dimensions.length; i++) {
           const c = complement(sl, this.dimensions[i]);
-          if(c.length > 0 && c.length < sl.length) {
-            this.dimensions[i].push(...c);
+          if(c.length < sl.length) {
+            if(c.length > 0) this.dimensions[i].push(...c);
             newdim = false;
             break;
           }
@@ -915,7 +926,7 @@ class LinnyRModel {
       for(let i = 0; i < c.notes.length; i++) {
         const
             n = c.notes[i],
-            tags = n.contents.match(/\[\[[^\]]+\]\]/g);
+            tags = n.tagList;
         if(tags) {
           for(let i = 0; i < tags.length; i++) {
             const
@@ -1181,8 +1192,8 @@ class LinnyRModel {
     }
     const id = UI.nameToID(name);
     let d = this.namedObjectByID(id);
-    if(d) {
-      if(IO_CONTEXT && d !== this.equations_dataset) {
+    if(d && d !== this.equations_dataset) {
+      if(IO_CONTEXT) {
         IO_CONTEXT.supersede(d);
       } else {
         // Preserve name uniqueness
@@ -1205,8 +1216,6 @@ class LinnyRModel {
     if(eqds) {
       // Restore pointer to original equations dataset
       this.equations_dataset = eqds;
-      // Add included equations with prefixed names
-console.log('HERE', d);
       // Return the extended equations dataset
       return eqds;
     } else {
@@ -1564,6 +1573,75 @@ console.log('HERE', d);
     return true;
   }
   
+  get selectionAsXML() {
+    // Returns XML for the selected entities, and also for the entities
+    // referenced by expressions for their attributes.
+    // NOTE: the name and actor name of the focal cluster are added as
+    // attributes of the main node to permit "smart" renaming of
+    // entities when PASTE would result in name conflicts.
+    if(this.selection.length <= 0) return '';
+    const
+        fc_name = this.focal_cluster.name,
+        fc_actor = this.focal_cluster.actor.name,
+        entities = {
+          Cluster: [],
+          Link: [],
+          Constraint: [],
+          Note: [],
+          Product: [],
+          Process: []
+        },
+        extras = [],
+        from_tos = [],
+        xml = [],
+        ft_xml = [],
+        extra_xml = [];
+    for(let i = 0; i < this.selection.length; i++) {
+      const obj = this.selection[i];
+      entities[obj.type].push(obj);
+    }
+    for(let i = 0; i < entities.Note.length; i++) {
+      const n = entities.Note[i];
+      xml.push(n.asXML);
+    }
+    for(let i = 0; i < entities.Product.length; i++) {
+      xml.push(entities.Product[i].asXML);
+    }
+    for(let i = 0; i < entities.Process.length; i++) {
+      xml.push(entities.Process[i].asXML);
+    }
+    for(let i = 0; i < entities.Cluster.length; i++) {
+      xml.push(entities.Cluster[i].asXML);
+    }
+    for(let i = 0; i < entities.Link.length; i++) {
+      const l = entities.Link[i];
+      if(this.selection.indexOf(l.from_node) < 0) addDistinct(l.from_node, from_tos);
+      if(this.selection.indexOf(l.to_node) < 0) addDistinct(l.to_node, from_tos);
+      xml.push(l.asXML);
+    }
+    for(let i = 0; i < entities.Constraint.length; i++) {
+      const c = entities.Constraint[i];
+      if(this.selection.indexOf(c.from_node) < 0) addDistinct(c.from_node, from_tos);
+      if(this.selection.indexOf(c.to_node) < 0) addDistinct(c.to_node, from_tos);
+      xml.push(c.asXML);
+    }
+    for(let i = 0; i < from_tos.length; i++) {
+      const p = from_tos[i];
+      ft_xml.push('<from-to type="', p.type, '" name="', xmlEncoded(p.name));
+      if(p instanceof Process) ft_xml.push('" actor-name="', xmlEncoded(p.actor.name));
+      ft_xml.push('"></from-to>');
+    }
+    for(let i = 0; i < extras.length; i++) extra_xml.push(extras[i].asXML);
+    return ['<copy timestamp="', Date.now(),
+        '" model-timestamp="', this.time_created.getTime(),
+        '" cluster-name="', xmlEncoded(fc_name),
+        '" cluster-actor="', xmlEncoded(fc_actor),
+        '"><entities>', xml.join(''),
+        '</entities><from-tos>', ft_xml.join(''),
+        '</from-tos><extras>', extra_xml.join(''),
+        '</extras></copy>'].join('');
+  }
+  
   dropSelectionIntoCluster(c) {
     // Move all selected nodes to cluster `c`
     let n = 0,
@@ -2026,46 +2104,74 @@ console.log('HERE', d);
       }
     }
   }
+
+  get datasetVariables() {
+    // Returns list with all ChartVariable objects in this model that
+    // reference a regular dataset, i.e., not an equation
+    const vl = [];
+    for(let i = 0; i < MODEL.charts.length; i++) {
+      const c = MODEL.charts[i];
+      for(let j = 0; j < c.variables.length; j++) {
+        const v = c.variables[j];
+        if(v.object instanceof Dataset &&
+            v.object !== MODEL.equations_dataset) vl.push(v);
+      }
+    }
+    return vl;
+  }
+  
+  get notesWithTags() {
+    // Returns a list with all notes having tags [[...]] in this model
+    const nl = [];
+    for(let k in this.clusters) if(this.clusters.hasOwnProperty(k)) {
+      const c = this.clusters[k];
+      for(let i = 0; i < c.notes.length; i++) {
+        const n = c.notes[i];
+        if(n.tagList) nl.push(n);
+      }
+    }
+    return nl;
+  }
   
   get allExpressions() {
-    // Returns list of all Expression objects
+    // Returns list of all Expression objects in this model
     // NOTE: start with dataset expressions, so that when recompiling
     // their `level-based` property is set before recompiling the
     // other expressions
-    const x = [];
+    const xl = [];
     for(let k in this.datasets) if(this.datasets.hasOwnProperty(k)) {
       const ds = this.datasets[k];
       // NOTE: dataset modifier expressions include the equations
       for(let m in ds.modifiers) if(ds.modifiers.hasOwnProperty(m)) {
-        x.push(ds.modifiers[m].expression);
+        xl.push(ds.modifiers[m].expression);
       }
     }
     for(let k in this.actors) if(this.actors.hasOwnProperty(k)) {
-      x.push(this.actors[k].weight);
+      xl.push(this.actors[k].weight);
     }
     for(let k in this.processes) if(this.processes.hasOwnProperty(k)) {
       const p = this.processes[k];
-      x.push(p.lower_bound, p.upper_bound, p.initial_level, p.pace_expression);
+      xl.push(p.lower_bound, p.upper_bound, p.initial_level, p.pace_expression);
     }
     for(let k in this.products) if(this.products.hasOwnProperty(k)) {
       const p = this.products[k];
-      x.push(p.lower_bound, p.upper_bound, p.initial_level, p.price);
+      xl.push(p.lower_bound, p.upper_bound, p.initial_level, p.price);
     }
     for(let k in this.clusters) if(this.clusters.hasOwnProperty(k)) {
       const c = this.clusters[k];
       for(let i = 0; i < c.notes.length; i++) {
         const n = c.notes[i];
-        x.push(n.color);
+        xl.push(n.color);
       }
     }
     for(let k in this.links) if(this.links.hasOwnProperty(k)) {
       const l = this.links[k];
-      x.push(l.relative_rate, l.flow_delay);
+      xl.push(l.relative_rate, l.flow_delay);
     }
-    return x;
+    return xl;
   }
 
-  replaceEntityInExpressions(en1, en2) {
+  replaceEntityInExpressions(en1, en2, notify=true) {
     // Replace entity name `en1` by `en2` in all variables in all expressions
     // (provided that they are not identical)
     if(en1 === en2) return;
@@ -2091,8 +2197,12 @@ console.log('HERE', d);
       }
     }
     if(ioc.replace_count) {
-      UI.notify(`Renamed ${pluralS(ioc.replace_count, 'variable')} in ` +
-          pluralS(ioc.expression_count, 'expression'));
+      this.variable_count += ioc.replace_count;
+      this.expression_count += ioc.expression_count; 
+      if(notify) {
+        UI.notify(`Renamed ${pluralS(ioc.replace_count, 'variable')} in ` +
+            pluralS(ioc.expression_count, 'expression'));
+      }
     }
     // Also rename entities in parameters and outcomes of sensitivity analysis
     for(let i = 0; i < this.sensitivity_parameters.length; i++) {
@@ -2127,8 +2237,8 @@ console.log('HERE', d);
     const
         en = escapeRegex(ena[0].trim().replace(/\s+/g, ' ').toLowerCase()),
         at = ena[1].trim(),
-        raw = en.replace(/\s/, `\s+`) + `\s*\|\s*` + escapeRegex(at),
-        re = new RegExp(`\[\s*${raw}\s*(\@[^\]]+)?\s*\]`, 'gi');
+        raw = en.replace(/\s/, '\\s+') + '\\s*\\|\\s*' + escapeRegex(at),
+        re = new RegExp(String.raw`\[\s*${raw}\s*(\@[^\]]+)?\s*\]`, 'gi');
     // Count replacements made
     let n = 0;
     // Iterate over all expressions
@@ -4472,12 +4582,17 @@ class Note extends ObjectWithXYWH {
     }
   }
   
+  get tagList() {
+    // Returns a list of matches for [[...]], or NULL if none
+    return this.contents.match(/\[\[[^\]]+\]\]/g);
+  }
+  
   parseFields() {
     // Fills the list of fields by parsing all [[...]] tags in the text
     // NOTE: this does not affect the text itself; tags will be replaced
     // by numerical values only when drawing the note
     this.fields.length = 0;
-    const tags = this.contents.match(/\[\[[^\]]+\]\]/g);
+    const tags = this.tagList;
     if(tags) {
       for(let i = 0; i < tags.length; i++) {
         const
@@ -4584,7 +4699,7 @@ class Note extends ObjectWithXYWH {
     // Return a list with names of entities used in fields
     const
         fel = [],
-        tags = this.contents.match(/\[\[[^\]]+\]\]/g);
+        tags = this.tagList;
     for(let i = 0; i < tags.length; i++) {
       const
           tag = tags[i],
@@ -4608,7 +4723,7 @@ class Note extends ObjectWithXYWH {
     if(en1 === en2) return;
     const
         raw = en1.split(/\s+/).join('\\\\s+'),
-        re = new RegExp('\\[\\[\\s*' + raw + '\\s*(\\->|\\||\\])', 'g'),
+        re = new RegExp('\\[\\[\\s*' + raw + '\\s*(\\->|\\||\\])', 'gi'),
         tags = this.contents.match(re);
     if(tags) {
       for(let i = 0; i < tags.length; i++) {
@@ -4773,7 +4888,14 @@ class NodeBox extends ObjectWithXYWH {
   get numberContext() {
     // Returns the string to be used to evaluate #, so for clusters, processes
     // and products this is the string of trailing digits (or empty if none)
-    return endsWithDigits(this.name);
+    // of the node name, or if that does not end with a number, the trailing
+    // digits of the first prefix (from right to left) that does
+    const sn = UI.prefixesAndName(this.name);
+    let nc = endsWithDigits(sn.pop());
+    while(!nc && sn.length > 0) {
+      nc = endsWithDigits(sn.pop());
+    }
+    return nc;
   }
   
   rename(name, actor_name) {
@@ -7593,8 +7715,8 @@ class Link {
       tn = this.from_node;
     }
     // Otherwise, the FROM node is checked first
-    let nc = endsWithDigits(fn.name);
-    if(!nc) nc = endsWithDigits(tn.name);
+    let nc = fn.numberContext;
+    if(!nc) nc = tn.numberContext;
     return nc;
   }
     
@@ -7847,7 +7969,12 @@ class Dataset {
   
   get numberContext() {
     // Returns the string to be used to evaluate # (empty string if undefined)
-    return endsWithDigits(this.name);
+    const sn = UI.prefixesAndName(this.name);
+    let nc = endsWithDigits(sn.pop());
+    while(!nc && sn.length > 0) {
+      nc = endsWithDigits(sn.pop());
+    }
+    return nc;
   }
 
   get selectorList() {
@@ -7877,6 +8004,27 @@ class Dataset {
     return true;
   }
   
+  get inferPrefixableModifiers() {
+    // Returns list of dataset modifiers with expressions that do not
+    // reference any variable and hence could probably better be represented
+    // by a prefixed dataset having the expression value as its default
+    const pml = [];
+    if(this !== this.equations_dataset) {
+      const sl = this.plainSelectors;
+      for(let i = 0; i < sl.length; i++) {
+        if(!MODEL.isDimensionSelector(sl[i])) {
+          const
+              m = this.modifiers[sl[i].toLowerCase()],
+              x = m.expression;
+          // Static expressions without variables can also be used
+          // as dataset default value
+          if(x.isStatic && x.text.indexOf('[') < 0) pml.push(m);
+        }
+      }
+    }
+    return pml;
+  }
+
   get timeStepDuration() {
     // Returns duration of 1 time step on the time scale of this dataset
     return this.time_scale * VM.time_unit_values[this.time_unit];
@@ -8045,11 +8193,11 @@ class Dataset {
     }
     if(this.default_selector) {
       // If no experiment (so "normal" run), use default selector if specified
-      const dm = this.modifiers[this.default_selector];
+      const dm = this.modifiers[UI.nameToID(this.default_selector)];
       if(dm) return dm.expression;
       // Exception should never occur, but check anyway and log it 
       console.log('WARNING: Dataset "' + this.name +
-          `" has no default selector "${this.default_selector}"`);
+          `" has no default selector "${this.default_selector}"`, this.modifiers);
     }
     // Fall-through: return vector instead of expression
     return this.vector;
@@ -8176,15 +8324,17 @@ class Dataset {
       }
     }
     const ds = xmlDecoded(nodeContentByTag(node, 'default-selector'));
-    if(ds && !this.modifiers[ds]) {
+    if(ds && !this.modifiers[UI.nameToID(ds)]) {
       UI.warn(`Dataset <tt>${this.name}</tt> has no selector <tt>${ds}</tt>`);
     } else {
       this.default_selector = ds;      
     }
   }
   
-  rename(name) {
+  rename(name, notify=true) {
     // Change the name of this dataset
+    // When `notify` is FALSE, notifications are suppressed while the
+    // number of affected datasets and expressions are counted
     // NOTE: prevent renaming the equations dataset (just in case...)
     if(this === MODEL.equations_dataset) return;
     name = UI.cleanName(name);
@@ -8204,7 +8354,7 @@ class Dataset {
     this.name = name;
     MODEL.datasets[new_id] = this;
     if(old_id !== new_id) delete MODEL.datasets[old_id];
-    MODEL.replaceEntityInExpressions(old_name, name);
+    MODEL.replaceEntityInExpressions(old_name, name, notify);
     return MODEL.datasets[new_id];
   }
   
@@ -9677,7 +9827,7 @@ class ExperimentRunResult {
     return ['<run-result', (this.x_variable ? ' x-variable="1"' : ''),
       (this.was_ignored ? ' ignored="1"' : ''),
       '><object-id>', xmlEncoded(this.object_id),
-      '</object-id><attribute>', this.attribute,
+      '</object-id><attribute>', xmlEncoded(this.attribute),
       '</attribute><count>', this.N,
       '</count><sum>', this.sum,
       '</sum><mean>', this.mean,
@@ -9695,7 +9845,12 @@ class ExperimentRunResult {
     this.x_variable = nodeParameterValue(node, 'x-variable') === '1';
     this.was_ignored = nodeParameterValue(node, 'ignored') === '1';
     this.object_id = xmlDecoded(nodeContentByTag(node, 'object-id'));
-    this.attribute = nodeContentByTag(node, 'attribute');
+    // NOTE: special check to guarantee upward compatibility to version
+    // 1.3.0 and higher
+    let attr = nodeContentByTag(node, 'attribute');
+    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'));
@@ -10126,6 +10281,17 @@ class Experiment {
     return index;
   }
   
+  isDimensionSelector(s) {
+    // Returns TRUE if `s` is a dimension selector in this experiment
+    for(let i = 0; i < this.dimensions.length; i++) {
+      if(this.dimensions[i].indexOf(s) >= 0) return true;
+    }
+    if(this.settings_selectors.indexOf(s) >= 0) return true;
+    if(this.combination_selectors.indexOf(s) >= 0) return true;
+    if(this.actor_selectors.indexOf(s) >= 0) return true;
+    return false;
+  }
+  
   get asXML() {
     let d = '';
     for(let i = 0; i < this.dimensions.length; i++) {

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

@@ -65,8 +65,11 @@ function pluralS(n, s, special='') {
 function safeStrToFloat(str, val=0) {
   // Returns numeric value of floating point string, interpreting both
   // dot and comma as decimal point
-  // NOTE: returns default value val if str is empty, null or undefined
-  const f = (str ? parseFloat(str.replace(',', '.')) : val);
+  // NOTE: returns default value `val` if `str` is empty, null or undefined,
+  // or contains a character that is invalid in a number 
+  if(!str || str.match(/[^0-9eE\.\,\+\-]/)) return val;
+  str = str.replace(',', '.');
+  const f = (str ? parseFloat(str) : val);
   return (isNaN(f) ? val : f);
 }
 
@@ -186,6 +189,20 @@ function ellipsedText(text, n=50, m=10) {
 // Functions used when comparing two Linny-R models
 //
 
+function earlierVersion(v1, v2) {
+  // Compares two version numbers and returns TRUE iff `v1` is earlier
+  // than `v2`
+  v1 = v1.split('.');
+  v2 = v2.split('.');
+  for(let i = 0; i < Math.min(v1.length, v2.length); i++) {
+    // NOTE: for legacy JS models, the major version number evaluates as 0
+    if(safeStrToInt(v1[i]) < safeStrToInt(v2[i])) return true;
+    if(safeStrToInt(v1[i]) > safeStrToInt(v2[i])) return false;
+  }
+  // Fall-through: same version numbers => NOT earlier
+  return false;
+}
+
 function differences(a, b, props) {
   // Compares values of properties (in list `props`) of entities `a` and `b`,
   // and returns a "dictionary" object with differences
@@ -310,18 +327,34 @@ 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 
   for(let i = 0; i < patterns.length; i++) {
     const p = patterns[i];
-    let match = true;
+    let pm,
+        match = true;
     for(let j = 0; j < p.plus.length; j++) {
-      match = match && str.indexOf(p.plus[j]) >= 0;
+      pm = p.plus[j];
+      if(pm.startsWith('=')) {
+        match = match && str === pm.substring(1);
+      } else if(pm.startsWith('~')) {
+        match = match && str.startsWith(pm.substring(1));
+      } else {
+        match = match && str.indexOf(pm) >= 0;
+      }
     }
     for(let j = 0; j < p.min.length; j++) {
-      match = match && str.indexOf(p.min[j]) < 0;
-    }
-    if(match) {
-      return true;
+      pm = p.min[j];
+      if(pm.startsWith('=')) {
+        match = match && str !== pm.substring(1);
+      } else if(pm.startsWith('~')) {
+        match = match && !str.startsWith(pm.substring(1));
+      } else {
+        match = match && str.indexOf(pm) < 0;
+      }
     }
+    if(match) return true;
   }
   return false;
 }
@@ -508,9 +541,9 @@ function childNodeByTag(node, tag) {
   // Returns the XML child node of `node` having node name `tag`, or NULL if
   // no such child node exists
   let cn = null;
-  for (let i = 0; i < node.children.length; i++) {
-    if(node.children[i].tagName === tag) {
-      cn = node.children[i];
+  for (let i = 0; i < node.childNodes.length; i++) {
+    if(node.childNodes[i].tagName === tag) {
+      cn = node.childNodes[i];
       break;
     }
   }
@@ -745,16 +778,21 @@ if(NODE) module.exports = {
   pluralS: pluralS,
   safeStrToFloat: safeStrToFloat,
   safeStrToInt: safeStrToInt,
+  rangeToList: rangeToList,
   dateToString: dateToString,
   msecToTime: msecToTime,
   uniformDecimals: uniformDecimals,
   ellipsedText: ellipsedText,
+  earlierVersion: earlierVersion,
   differences: differences,
   markFirstDifference: markFirstDifference,
+  ciCompare: ciCompare,
   endsWithDigits: endsWithDigits,
   indexOfMatchingBracket: indexOfMatchingBracket,
   patternList: patternList,
   patternMatch: patternMatch,
+  compareSelectors: compareSelectors,
+  stringToFloatArray: stringToFloatArray,
   escapeRegex: escapeRegex,
   addDistinct: addDistinct,
   setString: setString,