@sdeverywhere/compile 0.7.30 → 0.7.32

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-subscripts.js

@@ -1,7 +1,6 @@
-import XLSX from 'xlsx'
-
 import { readCsv } from '../_shared/helpers.js'
 import { Subscript } from '../_shared/subscript.js'
+import { decodeCell } from '../_shared/xlsx.js'
 
 /**
  * Read the dimension definitions from the given model.
@@ -46,7 +45,7 @@ export function readDimensionDefs(parsedModel) {
  */
 export function getDirectSubscripts(fileName, tabOrDelimiter, firstCell, lastCell) {
   // If lastCell is a column letter, scan the column, else scan the row
-  const dataAddress = XLSX.utils.decode_cell(firstCell.toUpperCase())
+  const dataAddress = decodeCell(firstCell.toUpperCase())
   let col = dataAddress.c
   let row = dataAddress.r
   if (col < 0 || row < 0) {

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++) {