@sdeverywhere/compile 0.7.27 → 0.7.29

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.27",
+  "version": "0.7.29",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
   "main": "./src/index.js",
   "dependencies": {
-    "@sdeverywhere/parse": "^0.1.2",
+    "@sdeverywhere/parse": "^0.1.4",
     "byline": "^5.0.0",
     "csv-parse": "^5.3.3",
     "ramda": "^0.27.0",

package/src/_shared/helpers.js

@@ -127,10 +127,10 @@ export let listConcat = (a, x, addSpaces = false) => {
 }
 // Convert a number or string into a C double constant string.
 // A blank string is converted to zero, following Excel.
-// A string that cannot be converted throws an exception.
+// A string that cannot be converted throws an error.
 export let cdbl = x => {
   function throwError() {
-    throw new Error(`ERROR: cannot convert "${x}" to a number`)
+    throw new Error(`Cannot convert "${x}" to a number`)
   }
   let s = '0.0'
   if (typeof x === 'number') {

package/src/generate/direct-data-helpers.js

@@ -48,7 +48,16 @@ function handleExcelWorkbook(fileOrTag, workbook, tab, dataKind, dataSource) {
     if (sheet) {
       return (c, r) => {
         let cell = sheet[XLSX.utils.encode_cell({ c, r })]
-        return cell != null ? cdbl(cell.v) : null
+        if (cell == null || cell.v === '') {
+          return null
+        }
+        try {
+          return cdbl(cell.v)
+        } catch (_error) {
+          // Return null when the cell value cannot be converted to a number;
+          // the caller will treat this as the end of data.
+          return null
+        }
       }
     } else {
       throw new Error(`Direct ${dataKind} worksheet ${tab} in ${dataSource} ${fileOrTag} not found`)
@@ -72,13 +81,16 @@ function handleCsvFile(file, dataPathname, delimiter, dataKind) {
   let data = readCsv(dataPathname, delimiter)
   if (data) {
     return (c, r) => {
-      let value = '0.0'
+      if (data[r] == null || data[r][c] == null || data[r][c] === '') {
+        return null
+      }
       try {
-        value = data[r] != null && data[r][c] != null ? cdbl(data[r][c]) : null
-      } catch (error) {
-        console.error(`${error.message} in ${dataPathname}`)
+        return cdbl(data[r][c])
+      } catch (_error) {
+        // Return null when the cell value cannot be converted to a number;
+        // the caller will treat this as the end of data.
+        return null
       }
-      return value
     }
   } else {
     throw new Error(`Direct ${dataKind} file ${file} could not be read`)

package/src/generate/gen-code.js

@@ -17,8 +17,9 @@ import { generateJS } from './gen-code-js.js'
  * @param {Map<string, any>} opts.directData The mapping of dataset name used in a
  * `GET DIRECT DATA` call (e.g., `?data`) to the tabular data contained in the loaded
  * data file.
- * @param {string} opts.modelDirname The path to the directory containing the model
- * (used for resolving data files for `GET DIRECT SUBSCRIPT`).
+ * @param {string} opts.modelDirname The absolute path to the directory containing data
+ * (dat, xlsx, csv) files that are referenced by the model.  This path is used for
+ * resolving data files for `GET DIRECT SUBSCRIPT` calls.
  * @returns A string containing the generated code.
  */
 export function generateCode(parsedModel, opts) {

package/src/generate/gen-direct-const.js

@@ -82,7 +82,12 @@ export function generateDirectConstInit(variable, directData, modelDir) {
   for (let i = 0; i < cellOffsets.length; i++) {
     let rowOffset = cellOffsets[i][0] ? cellOffsets[i][0] : 0
     let colOffset = cellOffsets[i][1] ? cellOffsets[i][1] : 0
+    // Use 0.0 as a fallback when the cell is missing, empty, or contains a non-numeric value.
+    // (Vensim raises an error in this case, but SDE has historically tolerated invalid cells.)
     let dataValue = getCellValue(startCol + colOffset, startRow + rowOffset)
+    if (dataValue == null) {
+      dataValue = '0.0'
+    }
     let lhs = `${variable.varName}${lhsSubscripts[i] || ''}`
     lines.push(`  ${lhs} = ${dataValue};`)
   }

package/src/generate/gen-equation.js

@@ -116,6 +116,12 @@ export function generateEquation(variable, mode, extData, directData, modelDir,
     // Emit decl/init code for the lookup
     const lookupDef = generateLookupFromPoints(variable, mode, /*copy=*/ false, cLhs, loopIndexVars, outFormat)
     if (lookupDef.length > 0) {
+      if (mode === 'decl') {
+        // When declaring a lookup, even if the lookup variable includes dimensions (i.e., is
+        // partially apply-to-all), the data variable declarations should not be inside for loops,
+        // so we omit them in this case
+        return [...lookupDef]
+      }
       return [...openLoops, ...lookupDef, ...closeLoops]
     } else {
       return []

package/src/generate/gen-expr.js

@@ -162,8 +162,28 @@ export function generateExpr(expr, ctx) {
  * @return {string} The generated C/JS code.
  */
 function generateFunctionCall(callExpr, ctx) {
-  const fnId = callExpr.fnId
+  function generateSimpleFunctionCall(fnId) {
+    const args = callExpr.args.map(argExpr => generateExpr(argExpr, ctx))
+    if (ctx.outFormat === 'js' && fnId === '_IF_THEN_ELSE') {
+      // When generating conditional expressions for JS target, since we can't rely on macros like we do for C,
+      // it is better to translate it into a ternary instead of relying on a built-in function (since the latter
+      // would require always evaluating both branches, while the former can be more optimized by the interpreter)
+      return `((${args[0]}) ? (${args[1]}) : (${args[2]}))`
+    } else {
+      // For simple functions, emit a C/JS function call with a generated C/JS expression for each argument
+      return `${fnRef(fnId, ctx)}(${args.join(', ')})`
+    }
+  }
 
+  function generateLookupFunctionCall(fnId) {
+    // For LOOKUP* functions, the first argument must be a reference to the lookup variable.  Emit
+    // a C/JS function call with a generated C/JS expression for each remaining argument.
+    const cVarRef = ctx.cVarRef(callExpr.args[0])
+    const cArgs = callExpr.args.slice(1).map(arg => generateExpr(arg, ctx))
+    return `${fnRef(fnId, ctx)}(${cVarRef}, ${cArgs.join(', ')})`
+  }
+
+  const fnId = callExpr.fnId
   switch (fnId) {
     //
     //
@@ -174,46 +194,54 @@ function generateFunctionCall(callExpr, ctx) {
     //
     //
 
+    // Simple functions that are common to Vensim and XMILE/Stella
     case '_ABS':
     case '_ARCCOS':
     case '_ARCSIN':
     case '_ARCTAN':
     case '_COS':
     case '_EXP':
-    case '_GAMMA_LN':
     case '_IF_THEN_ELSE':
-    case '_INTEGER':
     case '_LN':
     case '_MAX':
     case '_MIN':
-    case '_MODULO':
-    case '_POW':
-    case '_POWER':
-    case '_PULSE':
-    case '_PULSE_TRAIN':
-    case '_QUANTUM':
     case '_RAMP':
     case '_SIN':
     case '_SQRT':
     case '_STEP':
     case '_TAN':
+      return generateSimpleFunctionCall(fnId)
+
+    // Simple functions supported by Vensim only
+    case '_GAMMA_LN':
+    case '_INTEGER':
+    case '_MODULO':
+    case '_POW':
+    case '_POWER':
+    case '_PULSE_TRAIN':
+    case '_PULSE':
+    case '_QUANTUM':
     case '_WITH_LOOKUP':
     case '_XIDZ':
-    case '_ZIDZ': {
-      const args = callExpr.args.map(argExpr => generateExpr(argExpr, ctx))
+    case '_ZIDZ':
       if (ctx.outFormat === 'js' && fnId === '_GAMMA_LN') {
         throw new Error(`${callExpr.fnName} function not yet implemented for JS code gen`)
       }
-      if (ctx.outFormat === 'js' && fnId === '_IF_THEN_ELSE') {
-        // When generating conditional expressions for JS target, since we can't rely on macros like we do for C,
-        // it is better to translate it into a ternary instead of relying on a built-in function (since the latter
-        // would require always evaluating both branches, while the former can be more optimized by the interpreter)
-        return `((${args[0]}) ? (${args[1]}) : (${args[2]}))`
-      } else {
-        // For simple functions, emit a C/JS function call with a generated C/JS expression for each argument
-        return `${fnRef(fnId, ctx)}(${args.join(', ')})`
-      }
-    }
+      return generateSimpleFunctionCall(fnId)
+
+    // Simple functions supported by XMILE/Stella only
+    case '_INT':
+      // XMILE/Stella uses `INT`, but it is the same as the Vensim `INTEGER` function,
+      // which is the name used in the runtime function implementation
+      return generateSimpleFunctionCall('_INTEGER')
+    case '_MOD':
+      // XMILE/Stella uses `MOD`, but it is the same as the Vensim `MODULO` function,
+      // which is the name used in the runtime function implementation
+      return generateSimpleFunctionCall('_MODULO')
+    case '_SAFEDIV':
+      // XMILE/Stella uses `SAFEDIV`, but it is the same as the Vensim `ZIDZ` function,
+      // which is the name used in the runtime function implementation
+      return generateSimpleFunctionCall('_ZIDZ')
 
     //
     //
@@ -225,17 +253,12 @@ function generateFunctionCall(callExpr, ctx) {
     //
     //
 
+    // Lookup functions supported by Vensim only
     case '_GET_DATA_BETWEEN_TIMES':
     case '_LOOKUP_BACKWARD':
     case '_LOOKUP_FORWARD':
-    case '_LOOKUP_INVERT': {
-      // For LOOKUP* functions, the first argument must be a reference to the lookup variable.  Emit
-      // a C/JS function call with a generated C/JS expression for each remaining argument.
-      const cVarRef = ctx.cVarRef(callExpr.args[0])
-      const cArgs = callExpr.args.slice(1).map(arg => generateExpr(arg, ctx))
-      return `${fnRef(fnId, ctx)}(${cVarRef}, ${cArgs.join(', ')})`
-    }
-
+    case '_LOOKUP_INVERT':
+      return generateLookupFunctionCall(fnId)
     case '_GAME': {
       // For the GAME function, emit a C/JS function call that has the synthesized game inputs lookup
       // as the first argument, followed by the default value argument from the function call
@@ -244,6 +267,16 @@ function generateFunctionCall(callExpr, ctx) {
       return `${fnRef(fnId, ctx)}(${cLookupArg}, ${cDefaultArg})`
     }
 
+    // Lookup functions supported by XMILE/Stella only
+    case '_LOOKUP':
+      // XMILE/Stella has an explicit `LOOKUP` function while Vensim uses `x(y)` syntax, but
+      // underneath both are implemented at runtime by the `LOOKUP` function
+      return generateLookupFunctionCall('_LOOKUP')
+    case '_LOOKUPINV':
+      // XMILE/Stella uses `LOOKUPINV`, but it is the same as the Vensim `LOOKUP INVERT` function,
+      // which is the name used in the runtime function implementation
+      return generateLookupFunctionCall('_LOOKUP_INVERT')
+
     //
     //
     // Level functions
@@ -251,12 +284,16 @@ function generateFunctionCall(callExpr, ctx) {
     //
 
     case '_ACTIVE_INITIAL':
+    case '_DELAY':
     case '_DELAY_FIXED':
     case '_DEPRECIATE_STRAIGHTLINE':
     case '_SAMPLE_IF_TRUE':
     case '_INTEG':
       // Split level functions into init and eval expressions
-      if (ctx.outFormat === 'js' && (fnId === '_DELAY_FIXED' || fnId === '_DEPRECIATE_STRAIGHTLINE')) {
+      if (
+        ctx.outFormat === 'js' &&
+        (fnId === '_DELAY' || fnId === '_DELAY_FIXED' || fnId === '_DEPRECIATE_STRAIGHTLINE')
+      ) {
         throw new Error(`${callExpr.fnName} function not yet implemented for JS code gen`)
       }
       if (ctx.mode.startsWith('init')) {
@@ -311,7 +348,12 @@ function generateFunctionCall(callExpr, ctx) {
     case '_SMOOTH':
     case '_SMOOTHI':
     case '_SMOOTH3':
-    case '_SMOOTH3I': {
+    case '_SMOOTH3I':
+    case '_SMTH1':
+    case '_SMTH3': {
+      // Note that Vensim uses `SMOOTH[I]` and `SMOOTH3[I]` while XMILE uses `SMTH1` and
+      // `SMTH3`, but otherwise they have been translated the same way during the read
+      // equations phase
       const smoothVar = Model.varWithRefId(ctx.variable.smoothVarRefId)
       return ctx.cVarRef(smoothVar.parsedEqn.lhs.varDef)
     }
@@ -345,24 +387,31 @@ function generateFunctionCall(callExpr, ctx) {
       }
       return generateAllocateAvailableCall(callExpr, ctx)
 
-    case '_ELMCOUNT': {
-      // Emit the size of the dimension in place of the dimension name
+    case '_ELMCOUNT':
+    case '_SIZE': {
+      // Emit the size of the dimension in place of the dimension name. Note that Vensim uses
+      // `ELMCOUNT` while XMILE uses `SIZE`, but otherwise they are the same.
       const dimArg = callExpr.args[0]
       if (dimArg.kind !== 'variable-ref') {
-        throw new Error('Argument for ELMCOUNT must be a dimension name')
+        throw new Error(`Argument for ${callExpr.fnName} must be a dimension name`)
       }
       const dimId = dimArg.varId
       return `${sub(dimId).size}`
     }
 
     case '_GET_DIRECT_CONSTANTS':
+    case '_GET_XLS_CONSTANTS':
     case '_GET_DIRECT_DATA':
+    case '_GET_XLS_DATA':
     case '_GET_DIRECT_LOOKUPS':
+    case '_GET_XLS_LOOKUPS':
       // These functions are handled at a higher level, so we should not get here
       throw new Error(`Unexpected function '${fnId}' in code gen for '${ctx.variable.modelLHS}'`)
 
     case '_INITIAL':
-      // In init mode, only emit the initial expression without the INITIAL function call
+    case '_INIT':
+      // Note that Vensim uses `INITIAL` while XMILE uses `INIT`, but otherwise they are the same.
+      // In init mode, only emit the initial expression without the INITIAL function call.
       if (ctx.mode.startsWith('init')) {
         return generateExpr(callExpr.args[0], ctx)
       } else {
@@ -423,6 +472,7 @@ function generateLevelInit(callExpr, ctx) {
     case '_INTEG':
       initialArgIndex = 1
       break
+    case '_DELAY':
     case '_DELAY_FIXED': {
       // Emit the code that initializes the `FixedDelay` support struct
       const fixedDelay = ctx.cVarRefWithLhsSubscripts(ctx.variable.fixedDelayVarName)
@@ -474,12 +524,15 @@ function generateLevelEval(callExpr, ctx) {
       // For ACTIVE INITIAL, emit the first arg without a function call
       return generateExpr(callExpr.args[0], ctx)
 
+    case '_DELAY':
     case '_DELAY_FIXED': {
-      // For DELAY FIXED, emit the first arg followed by the FixedDelay support var
+      // Stella's DELAY function is behaviorally equivalent to Vensim's DELAY FIXED function, so
+      // they use the same `_DELAY_FIXED` runtime function.  For these, emit the first arg
+      // followed by the FixedDelay support var.
       const args = []
       args.push(generateExpr(callExpr.args[0], ctx))
       args.push(ctx.cVarRefWithLhsSubscripts(ctx.variable.fixedDelayVarName))
-      return generateCall(args)
+      return `${fnRef('_DELAY_FIXED', ctx)}(${args.join(', ')})`
     }
 
     case '_DEPRECIATE_STRAIGHTLINE': {
@@ -920,6 +973,7 @@ function visitVariableRefs(expr, onVarRef) {
       break
 
     case 'lookup-call':
+      visitVariableRefs(expr.varRef, onVarRef)
       visitVariableRefs(expr.arg, onVarRef)
       break
 

package/src/generate/gen-lookup-from-direct.js

@@ -89,14 +89,21 @@ function generateDirectDataLookup(varLhs, getCellValue, timeRowOrCol, startCell,
     }
   }
 
-  let timeValue = getCellValue(timeCol, timeRow)
-  let dataValue = getCellValue(dataCol, dataRow)
-  while (timeValue != null && dataValue != null) {
-    lookupData = listConcat(lookupData, `${timeValue}, ${dataValue}`, true)
-    lookupSize++
+  // Read time/value pairs, matching Vensim's behavior:
+  //   - Stop reading when the first non-numeric time value is encountered.  This
+  //     allows additional content (e.g., labels) to follow the data in the row or column.
+  //   - Skip pairs with a non-numeric data value, but continue reading subsequent pairs.
+  while (true) {
+    const timeValue = getCellValue(timeCol, timeRow)
+    if (timeValue == null) {
+      break
+    }
+    const dataValue = getCellValue(dataCol, dataRow)
+    if (dataValue != null) {
+      lookupData = listConcat(lookupData, `${timeValue}, ${dataValue}`, true)
+      lookupSize++
+    }
     nextCell()
-    dataValue = getCellValue(dataCol, dataRow)
-    timeValue = getCellValue(timeCol, timeRow)
   }
   if (lookupSize === 0) {
     throw new Error(`Empty lookup data array for ${varLhs}`)

package/src/index.js

@@ -35,7 +35,15 @@ export function parseInlineVensimModel(mdlContent /*: string*/, modelDir /*?: st
   // the preprocess step, and in the case of the new parser (which implicitly runs the
   // preprocess step), don't sort the definitions.  This makes it easier to do apples
   // to apples comparisons on the outputs from the two parser implementations.
-  return parseModel(mdlContent, modelDir, { sort: false })
+  return parseModel(mdlContent, 'vensim', modelDir, { sort: false })
+}
+
+/**
+ * @hidden This is not yet part of the public API; it is exposed only for use
+ * in the experimental playground app.
+ */
+export function parseInlineXmileModel(mdlContent /*: string*/, modelDir /*?: string*/) /*: ParsedModel*/ {
+  return parseModel(mdlContent, 'xmile', modelDir)
 }
 
 /**

package/src/model/model.js

@@ -1,7 +1,9 @@
 import * as R from 'ramda'
 
+import { canonicalVarId, toPrettyString } from '@sdeverywhere/parse'
+
 import B from '../_shared/bufx.js'
-import { canonicalVensimName, decanonicalize, isIterable, strlist, vlog, vsort } from '../_shared/helpers.js'
+import { decanonicalize, isIterable, strlist, vlog, vsort } from '../_shared/helpers.js'
 import {
   addIndex,
   allAliases,
@@ -15,7 +17,7 @@ import {
 import { cName } from '../_shared/var-names.js'
 
 import { expandVar } from './expand-var-instances.js'
-import { readEquation } from './read-equations.js'
+import { readEquation, resolveXmileDimensionWildcards } from './read-equations.js'
 import { readDimensionDefs } from './read-subscripts.js'
 import { readVariables } from './read-variables.js'
 import { reduceVariables } from './reduce-variables.js'
@@ -92,10 +94,80 @@ function read(parsedModel, spec, extData, directData, modelDirname, opts) {
   timeVar.varName = '_time'
   vars.push(timeVar)
 
+  // Helper function to define a control variable for XMILE models
+  function defineXmileControlVar(varName, varId, rhsValue) {
+    let rhsExpr
+    if (typeof rhsValue === 'number') {
+      rhsExpr = {
+        kind: 'number',
+        value: rhsValue,
+        text: rhsValue.toString()
+      }
+    } else {
+      rhsExpr = {
+        kind: 'variable-ref',
+        varName: rhsValue,
+        varId: canonicalVarId(rhsValue)
+      }
+    }
+    const v = new Variable()
+    v.modelLHS = varName
+    v.varName = varId
+    v.parsedEqn = {
+      lhs: {
+        varDef: {
+          varName,
+          varId
+        }
+      },
+      rhs: {
+        kind: 'expr',
+        expr: rhsExpr
+      }
+    }
+    v.modelFormula = toPrettyString(rhsExpr, { compact: true })
+    v.includeInOutput = false
+    vars.push(v)
+  }
+
+  if (parsedModel.kind === 'xmile') {
+    // XXX: Unlike Vensim models, XMILE models do not include the control parameters as
+    // normal model equations; instead, they are defined in the `<sim_specs>` element.
+    // In addition, XMILE allows these values to be accessed in equations (e.g., `<start>`
+    // can be accessed as `STARTTIME`, `<stop>` as `STOPTIME`, and `<dt>` as `DT`).
+    // For compatibility with the existing runtime code (which expects these variables
+    // to be defined using the Vensim names), we will synthesize variables using the
+    // Vensim names (e.g., `INITIAL TIME`) and also synthesize variables that derive
+    // from these using the XMILE names (e.g., `STARTTIME`).
+    defineXmileControlVar('INITIAL TIME', '_initial_time', parsedModel.root.simulationSpec.startTime)
+    defineXmileControlVar('FINAL TIME', '_final_time', parsedModel.root.simulationSpec.endTime)
+    defineXmileControlVar('TIME STEP', '_time_step', parsedModel.root.simulationSpec.timeStep)
+    defineXmileControlVar('STARTTIME', '_starttime', 'INITIAL TIME')
+    defineXmileControlVar('STOPTIME', '_stoptime', 'FINAL TIME')
+    defineXmileControlVar('DT', '_dt', 'TIME STEP')
+    // XXX: For now, also include a `SAVEPER` variable that is the same as `TIME STEP` (is there
+    // an equivalent of this in XMILE?)
+    defineXmileControlVar('SAVEPER', '_saveper', 'TIME STEP')
+  }
+
   // Add the variables to the `Model`
   vars.forEach(addVariable)
   if (opts?.stopAfterReadVariables) return
 
+  if (parsedModel.kind === 'xmile') {
+    // XXX: In the case of XMILE, we need to resolve any wildcards used in dimension
+    // position in the RHS of the equation
+    for (const variable of vars) {
+      if (variable.parsedEqn?.rhs?.kind === 'expr') {
+        const updatedEqn = resolveXmileDimensionWildcards(variable)
+        if (updatedEqn) {
+          variable.parsedEqn = updatedEqn
+          variable.modelFormula = toPrettyString(updatedEqn.rhs.expr, { compact: true })
+        }
+      }
+    }
+  }
+
   if (spec) {
     // If the spec file contains `input/outputVarNames`, convert the full Vensim variable
     // names to C names first so that later phases only need to work with canonical names
@@ -268,7 +340,7 @@ function resolveDimensions(dimensionFamilies) {
   }
 }
 
-function analyze(parsedModelKind, inputVars, opts) {
+function analyze(modelKind, inputVars, opts) {
   // Analyze the RHS of each equation in stages after all the variables are read.
   // Find non-apply-to-all vars that are defined with more than one equation.
   findNonAtoAVars()
@@ -284,7 +356,9 @@ function analyze(parsedModelKind, inputVars, opts) {
   if (opts?.stopAfterReduceVariables === true) return
 
   // Read the RHS to list the refIds of vars that are referenced and set the var type.
-  variables.forEach(readEquation)
+  variables.forEach(v => {
+    readEquation(v, modelKind)
+  })
 }
 
 function checkSpecVars(spec) {
@@ -1221,7 +1295,7 @@ function jsonList() {
 
       const varInstances = expandVar(v)
       for (const { varName, subscriptIndices } of varInstances) {
-        const varId = canonicalVensimName(varName)
+        const varId = canonicalVarId(varName)
         const varItem = {
           varId,
           varName,

package/src/model/read-equation-fn-delay.js

@@ -16,10 +16,12 @@ import Model from './model.js'
 /**
  * Generate level and aux variables that implement one of the following `DELAY` function
  * call variants:
- * - DELAY1
- * - DELAY1I
- * - DELAY3
- * - DELAY3I
+ * - DELAY1 (Vensim)
+ * - DELAY1I (Vensim)
+ * - DELAY3 (Vensim)
+ * - DELAY3I (Vensim)
+ * - DELAY1 (Stella)
+ * - DELAY3 (Stella)
  *
  * TODO: Docs
  *

package/src/model/read-equation-fn-smooth.js

@@ -15,10 +15,12 @@ import Model from './model.js'
 /**
  * Generate level and aux variables that implement one of the following `SMOOTH` function
  * call variants:
- * - SMOOTH
- * - SMOOTHI
- * - SMOOTH3
- * - SMOOTH3I
+ * - SMOOTH (Vensim)
+ * - SMOOTHI (Vensim)
+ * - SMOOTH3 (Vensim)
+ * - SMOOTH3I (Vensim)
+ * - SMTH1 (Stella)
+ * - SMTH3 (Stella)
  *
  * TODO: Docs
  *
@@ -43,7 +45,7 @@ export function generateSmoothVariables(v, callExpr, context) {
   }
 
   const fnId = callExpr.fnId
-  if (fnId === '_SMOOTH' || fnId === '_SMOOTHI') {
+  if (fnId === '_SMOOTH' || fnId === '_SMOOTHI' || fnId === '_SMTH1') {
     // Generate 1 level variable that will replace the `SMOOTH[I]` function call
     const level = generateSmoothLevel(v, context, argInput, argDelay, argInit, 1)
     // For `SMOOTH[I]`, the smoothVarRefId is the level var's refId

package/src/model/read-equation-fn-trend.js

@@ -3,7 +3,7 @@ import { toPrettyString } from '@sdeverywhere/parse'
 import { canonicalName, newAuxVarName, newLevelVarName } from '../_shared/helpers.js'
 
 /**
- * Generate two level variables and one aux that implement an `NPV` function call.
+ * Generate two level variables and one aux that implement an `TREND` function call.
  *
  * TODO: Docs
  *

package/src/model/read-equations-expand.js

@@ -0,0 +1,72 @@
+import { indexNamesForSubscript } from '../_shared/subscript.js'
+
+/**
+ * Given the array of LHS subscript/dimension IDs (already mapped to correspond to the
+ * RHS positions) and a set of RHS variable instances, return the refIds of the RHS
+ * instances whose subscript combinations overlap with the LHS combinations at every
+ * position.
+ *
+ * Conceptually, this is equivalent to checking whether any combination in the LHS
+ * cartesian product matches any combination in a given RHS instance's cartesian
+ * product.  But because positions in a cartesian product are independent, we only
+ * need to check that each position has at least one index in common between the
+ * LHS and RHS index sets.  This reduces the complexity of the check from
+ * O(product of dimension sizes) to O(sum of dimension sizes).
+ *
+ * For example, suppose DimA={A1,A2} and DimB={B1,B2}, the LHS accesses `[DimA,DimB]`,
+ * and we want to check whether it overlaps with a RHS variable instance `_x[_dima,_b1]`.
+ * The full cartesian products look like this:
+ *   LHS combos: { (A1,B1), (A1,B2), (A2,B1), (A2,B2) }
+ *   RHS combos: { (A1,B1), (A2,B1) }
+ * The two sets share (A1,B1) and (A2,B1), so there is a match.  But we don't need
+ * to enumerate either set — we can check each position independently:
+ *   position 0:  LHS {A1,A2} ∩ RHS {A1,A2} = {A1,A2}  (non-empty)
+ *   position 1:  LHS {B1,B2} ∩ RHS {B1}    = {B1}     (non-empty)
+ * Every position has at least one index in common, so we know a full-combo match
+ * must exist (pick any shared index at each position, e.g., (A2,B1), and it is in
+ * both products).  Conversely, if any position has an empty intersection, no full
+ * combo can match — for example, if instead the LHS accessed `[A1,DimB]` (a specific
+ * index at position 0) and the RHS instance were `_x[_a2,_dimb]`, position 0 would
+ * give LHS {A1} ∩ RHS {A2} = ∅ and we could stop immediately.
+ *
+ * @param {string[]} mappedLhsSubIds The array of LHS subscript/dimension IDs at each
+ * position, mapped to correspond to the RHS variable reference positions.
+ * @param {{ subscripts: string[], refId: string }[]} rhsVarInstances The array of RHS
+ * variable instances to filter.
+ * @returns {string[]} A sorted array of refIds for the RHS instances whose subscripts
+ * overlap with the LHS at every position.
+ */
+export function matchingRhsRefIds(mappedLhsSubIds, rhsVarInstances) {
+  // Build a Set of LHS index names for each position for quick lookup
+  const lhsIndexSets = mappedLhsSubIds.map(id => new Set(indexNamesForSubscript(id)))
+
+  // For each RHS variable instance, check if there is overlap at every subscript
+  // position between the LHS and RHS index sets
+  const rhsRefIds = []
+  for (const rhsVarInstance of rhsVarInstances) {
+    let matches = true
+    for (let i = 0; i < rhsVarInstance.subscripts.length; i++) {
+      const rhsIndices = indexNamesForSubscript(rhsVarInstance.subscripts[i])
+      let hasOverlap = false
+      for (const id of rhsIndices) {
+        if (lhsIndexSets[i].has(id)) {
+          hasOverlap = true
+          break
+        }
+      }
+      if (!hasOverlap) {
+        matches = false
+        break
+      }
+    }
+    if (matches) {
+      rhsRefIds.push(rhsVarInstance.refId)
+    }
+  }
+
+  // Return the sorted array of relevant refIds
+  // TODO: Sorting is not essential here, but the legacy reader sorted so we will keep
+  // that behavior now to avoid invalidating tests.  Later we should remove this `sort`
+  // call and update the tests accordingly.
+  return rhsRefIds.sort()
+}