@sdeverywhere/compile 0.7.31 → 0.7.33

package/src/model/read-equations.js

@@ -508,6 +508,10 @@ function visitFunctionCall(v, callExpr, context) {
         argModes[2] = 'init'
         break
 
+      case '_DEMAND_AT_PRICE':
+        validateCallArgs(callExpr, 3)
+        break
+
       case '_DEPRECIATE_STRAIGHTLINE':
         validateCallDepth(callExpr, context)
         validateCallArgs(callExpr, 4)
@@ -522,6 +526,10 @@ function visitFunctionCall(v, callExpr, context) {
         argModes[2] = 'init'
         break
 
+      case '_FIND_MARKET_PRICE':
+        validateCallArgs(callExpr, 4)
+        break
+
       case '_GAME':
         validateCallDepth(callExpr, context)
         validateCallArgs(callExpr, 1)
@@ -587,6 +595,11 @@ function visitFunctionCall(v, callExpr, context) {
         argModes[1] = 'init'
         break
 
+      case '_INVERT_MATRIX':
+        validateCallDepth(callExpr, context)
+        validateCallArgs(callExpr, 2)
+        break
+
       case '_NPV':
         validateCallArgs(callExpr, 4)
         addFnReference = false
@@ -612,6 +625,10 @@ function visitFunctionCall(v, callExpr, context) {
         generateSmoothVariables(v, callExpr, context)
         break
 
+      case '_SUPPLY_AT_PRICE':
+        validateCallArgs(callExpr, 3)
+        break
+
       case '_TREND':
         validateCallArgs(callExpr, 3)
         addFnReference = false
@@ -847,25 +864,27 @@ function visitFunctionCall(v, callExpr, context) {
       if (callExpr.fnId === '_WITH_LOOKUP' && index > 1) {
         // XXX: For `WITH LOOKUP` calls, only process the first argument; need to generalize this
         break
-      } else if (callExpr.fnId === '_ALLOCATE_AVAILABLE' && index === 1) {
-        // Handle the second (`pp` or priority profile) argument of `ALLOCATE AVAILABLE` calls
+      } else if (
+        (callExpr.fnId === '_ALLOCATE_AVAILABLE' && index === 1) ||
+        (callExpr.fnId === '_DEMAND_AT_PRICE' && index === 1) ||
+        (callExpr.fnId === '_SUPPLY_AT_PRICE' && index === 1) ||
+        (callExpr.fnId === '_FIND_MARKET_PRICE' && (index === 1 || index === 3))
+      ) {
+        // Handle the second (`pp` or priority profile) argument of allocation function calls
         // specially.  An example call with a 2D `pp` looks like this:
         //   shipments[branch] = ALLOCATE AVAILABLE(demand[branch], priority[branch,ptype], avail) ~~|
         // Or a 3D `pp` with a dimension:
         //   shipments[item,branch] = ALLOCATE AVAILABLE(demand[branch], priority[item,branch,ptype], avail) ~~|
         // Or a 3D `pp` with a specific subscript:
         //   shipments[branch] = ALLOCATE AVAILABLE(demand[branch], priority[item1,branch,ptype], avail) ~~|
-        // Vensim requires passing a reference with `ptype` as the last subscript, but the function
-        // implementation uses the `ppriority` and `pwidth` values (the `ptype` is currently assumed
-        // to be 3).  Therefore we need to add references to all variants of the variable, not just
-        // the ones for `ptype`.
+        // Vensim requires passing a reference with `ptype` as the last subscript.
         if (argExpr.kind !== 'variable-ref') {
-          throw new Error(`ALLOCATE AVAILABLE argument 'pp' must be a variable reference`)
+          throw new Error(`${callExpr.fnName} argument 'pp' must be a variable reference`)
         }
         // TODO: Throw an error if the last dimension of arg0 does not match last dimension of LHS
         // TODO: Throw an error if the second-to-last dimension of arg1 does not match last dimension of LHS
         // TODO: Throw an error if the last subscript of arg1 does not have the "shape" of a `ppriority` dimension
-        // TODO: Throw an error if the `ptype` value is not 3
+        // TODO: Throw an error if the `ptype` value is unsupported
         // Get the RHS subscript/dimension IDs
         const rhsVarBaseRefId = argExpr.varId
         const rhsVarSubIds = argExpr.subscriptRefs?.map(subRef => subRef.subId) || []

package/src/model/read-variables.js

@@ -120,22 +120,27 @@ function variablesForEquation(eqn, specialSeparationDims, separateAllVarsWithDim
       let separationDims = specialSeparationDims[baseVarId] || []
       if (!Array.isArray(separationDims)) {
         separationDims = [separationDims]
+      } else {
+        // Copy the array so that the spec object is not mutated below
+        separationDims = [...separationDims]
       }
-      // Alternatively, if the variable was not in `specialSeparationDims`, separate
-      // on dims from `separateAllVarsWithDims` if the var matches one of the dim lists.
-      if (separationDims.length === 0) {
-        for (let dimList of separateAllVarsWithDims) {
-          // Technically we allow each entry in the spec array to be either a single
-          // dim ID string or an array of dim IDs, so convert to array if needed
-          if (!Array.isArray(dimList)) {
-            dimList = [dimList]
-          }
-          // The list entry from the spec is only considered a match if every dimension
-          // in the spec list appears on the LHS
-          if (dimList.every(dim => subIds.includes(dim))) {
-            separationDims = dimList
-            break
+      // Additionally, separate on dims from `separateAllVarsWithDims` if the var
+      // matches one of the dim lists.
+      for (let dimList of separateAllVarsWithDims) {
+        // Technically we allow each entry in the spec array to be either a single
+        // dim ID string or an array of dim IDs, so convert to array if needed
+        if (!Array.isArray(dimList)) {
+          dimList = [dimList]
+        }
+        // The list entry from the spec is only considered a match if every dimension
+        // in the spec list appears on the LHS
+        if (dimList.every(dim => subIds.includes(dim))) {
+          for (const dim of dimList) {
+            if (!separationDims.includes(dim)) {
+              separationDims.push(dim)
+            }
           }
+          break
         }
       }
       positionsToExpand = subscriptPositionsToExpand(subIds, exceptSubIdSets, separationDims, variable.modelFormula)

package/src/model/toposort.js

@@ -42,7 +42,19 @@ function toposort(nodes, edges) {
       } catch (_) {
         nodeRep = ''
       }
-      throw new Error('Found cyclic dependency during toposort:\n' + [...predecessors].join(' →\n') + ' →' + nodeRep)
+      var chain = [...predecessors]
+      var error = new Error('Found cyclic dependency during toposort:\n' + chain.join(' →\n') + ' →' + nodeRep)
+      // Attach the cycle itself (the portion of the dependency chain from the first
+      // occurrence of the repeated node) so that callers can analyze it.
+      error.cycle = chain.slice(chain.indexOf(node))
+      // Also attach all cycle clusters in the graph (the strongly connected components
+      // with more than one node, plus any single node that depends on itself) along
+      // with the graph edges so that callers can analyze every cycle at once.
+      error.cycles = stronglyConnectedComponents(nodes, outgoingEdges).filter(
+        scc => scc.length > 1 || (outgoingEdges.get(scc[0]) || new Set()).has(scc[0])
+      )
+      error.outgoingEdges = outgoingEdges
+      throw error
     }
 
     if (!nodesHash.has(node)) {
@@ -70,6 +82,76 @@ function toposort(nodes, edges) {
   }
 }
 
+/**
+ * Find the strongly connected components of the graph using an iterative form of
+ * Tarjan's algorithm (iterative to avoid stack overflow on the deep dependency
+ * chains found in large models).
+ *
+ * @param {Array} nodes The nodes in the graph.
+ * @param {Map} outgoingEdges A map of each node to the set of nodes that it points to.
+ * @returns {Array} An array of strongly connected components, where each component is
+ * an array of the nodes that it contains.
+ */
+function stronglyConnectedComponents(nodes, outgoingEdges) {
+  var index = 0
+  var nodeIndex = new Map()
+  var lowlink = new Map()
+  var onStack = new Set()
+  var stack = []
+  var sccs = []
+  for (var start of nodes) {
+    if (nodeIndex.has(start)) {
+      continue
+    }
+    var frames = [{ node: start, edges: null, i: 0, child: undefined }]
+    while (frames.length > 0) {
+      var frame = frames[frames.length - 1]
+      var node = frame.node
+      if (frame.edges === null) {
+        // First visit to this node
+        nodeIndex.set(node, index)
+        lowlink.set(node, index)
+        index++
+        stack.push(node)
+        onStack.add(node)
+        frame.edges = Array.from(outgoingEdges.get(node) || [])
+      } else if (frame.child !== undefined) {
+        // Returning from a child visit
+        lowlink.set(node, Math.min(lowlink.get(node), lowlink.get(frame.child)))
+        frame.child = undefined
+      }
+      var descended = false
+      while (frame.i < frame.edges.length) {
+        var w = frame.edges[frame.i++]
+        if (!nodeIndex.has(w)) {
+          frame.child = w
+          frames.push({ node: w, edges: null, i: 0, child: undefined })
+          descended = true
+          break
+        } else if (onStack.has(w)) {
+          lowlink.set(node, Math.min(lowlink.get(node), nodeIndex.get(w)))
+        }
+      }
+      if (descended) {
+        continue
+      }
+      // All edges have been visited, so the node is complete
+      if (lowlink.get(node) === nodeIndex.get(node)) {
+        var scc = []
+        var member
+        do {
+          member = stack.pop()
+          onStack.delete(member)
+          scc.push(member)
+        } while (member !== node)
+        sccs.push(scc)
+      }
+      frames.pop()
+    }
+  }
+  return sccs
+}
+
 function uniqueNodes(arr) {
   var res = new Set()
   for (var i = 0, len = arr.length; i < len; i++) {

package/src/parse-and-generate.js

@@ -6,6 +6,7 @@ import { parseVensimModel, parseXmileModel } from '@sdeverywhere/parse'
 
 import B from './_shared/bufx.js'
 import { readXlsx } from './_shared/helpers.js'
+import { normalizeModelSpec } from './_shared/normalize-model-spec.js'
 import { readDat } from './_shared/read-dat.js'
 import { printSubscripts } from './_shared/subscript.js'
 import { cName } from './_shared/var-names.js'
@@ -13,6 +14,34 @@ import Model from './model/model.js'
 import { getDirectSubscripts } from './model/read-subscripts.js'
 import { generateCode } from './generate/gen-code.js'
 
+/**
+ * The kind of model that is being parsed.
+ *
+ * @typedef {'vensim' | 'xmile'} ModelKind
+ */
+
+/**
+ * A parsed tree representation of a model, along with the kind of model that was parsed.
+ *
+ * @typedef {Object} ParsedModel
+ * @property {ModelKind} kind The kind of model that was parsed.
+ * @property {import('@sdeverywhere/parse').Model} root The root of the parsed model AST.
+ */
+
+/**
+ * An operation that can be performed by `parseAndGenerate`.
+ *
+ * - `generateC` writes the generated C code to the build directory.
+ * - `generateJS` writes the generated JS code to the build directory.
+ * - `printVarList` writes variables and subscripts to txt and json files under the build
+ *   directory.
+ * - `printRefIdTest` prints reference identifiers to the console.
+ * - `printRefGraph` prints the variable dependency graph to the console.
+ * - `convertNames` generates no output, but makes the results of model analysis available.
+ *
+ * @typedef {'generateC' | 'generateJS' | 'printVarList' | 'printRefIdTest' | 'printRefGraph' | 'convertNames'} GenerateOperation
+ */
+
 /**
  * Parse a Vensim or XMILE model and generate C code.
  *
@@ -27,27 +56,30 @@ import { generateCode } from './generate/gen-code.js'
  *   analysis will be available.
  *
  * @param {string} input The preprocessed Vensim or XMILE model text.
- * @param {string} modelKind The kind of model to parse, either 'vensim' or 'xmile'.
- * @param {*} spec The model spec (from the JSON file).
- * @param {string[]} operations The set of operations to perform; can include 'generateC', 'generateJS',
- * 'printVarList', 'printRefIdTest', 'convertNames'.  If the array is empty, the model will be
- * read but no operation will be performed.
+ * @param {ModelKind} modelKind The kind of model to parse.
+ * @param {import('./_shared/model-spec.js').ModelSpec} spec The model spec (from the JSON file).
+ * @param {GenerateOperation[]} operations The set of operations to perform.  If the array is
+ * empty, the model will be read but no operation will be performed.
  * @param {string} modelDirname The absolute path to the directory containing data (dat, xlsx, csv)
  * files that are referenced by the model.  These files will be resolved relative to this directory.
  * @param {string} modelName The model name (without the mdl extension).
  * @param {string} buildDir The output directory where the C or list files will be written.
  * @param {string} [varname] The variable name passed to the 'sde causes' command.
- * @return A string containing the generated C code.
+ * @return {Promise<string>} A promise that resolves with the generated C or JS code.
  */
 export async function parseAndGenerate(input, modelKind, spec, operations, modelDirname, modelName, buildDir, varname) {
+  // Resolve any deprecated property names in the spec so that we only need to
+  // consult the preferred names below
+  normalizeModelSpec(spec)
+
   // Read time series from external DAT files into a single object.
-  // externalDatfiles is an array of either filenames or objects
-  // giving a variable name prefix as the key and a filename as the value.
+  // `datFiles` is an array of either filenames or objects giving a variable
+  // name prefix as the key and a filename as the value.
   let extData = new Map()
-  if (spec.externalDatfiles) {
-    for (let datfile of spec.externalDatfiles) {
+  if (spec.datFiles) {
+    for (let datfile of spec.datFiles) {
       let prefix = ''
-      let filename = ''
+      let filename
       if (typeof datfile === 'object') {
         prefix = Object.keys(datfile)[0]
         filename = datfile[prefix]
@@ -110,8 +142,9 @@ export async function parseAndGenerate(input, modelKind, spec, operations, model
  *
  * This is used only to implement the `sde names` command.
  *
- * @param namesPathname The path to the file containing variables names.
- * @param operation Either 'to-c' or 'to-vensim'.
+ * @param {string} namesPathname The path to the file containing variables names.
+ * @param {'to-c' | 'to-vensim'} operation The conversion to perform.
+ * @return {void}
  */
 export function printNames(namesPathname, operation) {
   let lines = B.lines(B.read(namesPathname))
@@ -130,15 +163,13 @@ export function printNames(namesPathname, operation) {
 /**
  * Read and parse the given model text and return the parsed model structure.
  *
- * TODO: Fix return type
- *
  * @param {string} input The string containing the model text.
- * @param {string} modelKind The kind of model to parse, either 'vensim' or 'xmile'.
- * @param {string} modelDir The absolute path to the directory containing data (dat, xlsx, csv)
+ * @param {ModelKind} modelKind The kind of model to parse.
+ * @param {string} [modelDir] The absolute path to the directory containing data (dat, xlsx, csv)
  * files that are referenced by the model.  These files will be resolved relative to this directory.
  * @param {Object} [options] The options that control parsing.
- * @param {boolean} options.sort Whether to sort definitions alphabetically in the preprocess step.
- * @return {*} A parsed tree representation of the model.
+ * @param {boolean} [options.sort] Whether to sort definitions alphabetically in the preprocess step.
+ * @return {ParsedModel} A parsed tree representation of the model.
  */
 export function parseModel(input, modelKind, modelDir, options) {
   if (modelKind === 'vensim') {