@sdeverywhere/cli 0.7.3 → 0.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/cli",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "Contains the `sde` command line interface for the SDEverywhere tool suite.",
   "type": "module",
   "files": [
@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "@sdeverywhere/build": "^0.2.0",
-    "@sdeverywhere/compile": "^0.7.0",
+    "@sdeverywhere/compile": "^0.7.2",
     "bufx": "^1.0.5",
     "byline": "^5.0.0",
     "ramda": "^0.27.0",

package/src/c/vensim.c

@@ -434,11 +434,19 @@ FixedDelay* __new_fixed_delay(FixedDelay* fixed_delay, double delay_time, double
   // The delay time is quantized to an integral number of time steps.
   // The FixedDelay should be constructed at init time to latch the delay time and initial value.
   // Allocate memory on the first call only. Pass the same pointer back in on subsequent runs.
+  size_t n = (size_t)ceil(delay_time / _time_step);
+  size_t bufsize = n * sizeof(double);
   if (fixed_delay == NULL) {
+    // Create the FixedDelay object and allocate its data buffer.
     fixed_delay = malloc(sizeof(FixedDelay));
-    fixed_delay->n = (size_t)ceil(delay_time / _time_step);
-    fixed_delay->data = malloc(sizeof(double) * fixed_delay->n);
+    fixed_delay->data = malloc(bufsize);
+  } else if (fixed_delay->n != n) {
+    // The delay time has changed since a previous run. Reallocate the data buffer.
+    free(fixed_delay->data);
+    fixed_delay->data = malloc(bufsize);
   }
+  // Reset state at the start of each run.
+  fixed_delay->n = n;
   fixed_delay->data_index = 0;
   fixed_delay->initial_value = initial_value;
   return fixed_delay;
@@ -464,3 +472,54 @@ double _DELAY_FIXED(double input, FixedDelay* fixed_delay) {
   }
   return result;
 }
+
+//
+// DEPRECIATE STRAIGHTLINE
+//
+Depreciation* __new_depreciation(Depreciation* depreciation, double dtime, double initial_value) {
+  // Construct a Depreciation struct with a ring buffer for the time steps in the depreciation time.
+  // We don't know the size until runtime, so it must be dynamically allocated.
+  // The depreciation time is quantized to an integral number of time steps.
+  // The Depreciation should be constructed at init time to latch the depreciation time and initial value.
+  // Allocate memory on the first call only. Pass the same pointer back in on subsequent runs.
+  size_t n = (size_t)ceil(dtime / _time_step);
+  size_t bufsize = n * sizeof(double);
+  if (depreciation == NULL) {
+    // Create the Depreciation object and allocate its data buffer.
+    depreciation = malloc(sizeof(Depreciation));
+    depreciation->data = malloc(bufsize);
+  } else if (depreciation->n != n) {
+    // The depreciation time has changed since a previous run. Reallocate the data buffer.
+    free(depreciation->data);
+    depreciation->data = malloc(bufsize);
+  }
+  // Reset state at the start of each run.
+  memset(depreciation->data, 0, bufsize);
+  depreciation->n = n;
+  depreciation->data_index = 0;
+  depreciation->dtime = dtime;
+  depreciation->initial_value = initial_value;
+  return depreciation;
+}
+double _DEPRECIATE_STRAIGHTLINE(double input, Depreciation* depreciation) {
+  // Distribute the input at this time step over the depreciation time in a ring buffer.
+  // Return the depreciation amout at the current time.
+  double result;
+  // Require the buffer size to be positive to protect from buffer overflows.
+  if (depreciation->n > 0) {
+    // Distribute input from the stream over the depreciation time.
+    double distribution = input / depreciation->dtime;
+    for (size_t i = 0; i < depreciation->n; i++) {
+      size_t pos = (depreciation->data_index + i) % depreciation->n;
+      depreciation->data[pos] += distribution;
+    }
+    result = depreciation->data[depreciation->data_index];
+    // Move to the next time step by pushing zero and shifting.
+    depreciation->data[depreciation->data_index] = 0;
+    depreciation->data_index = (depreciation->data_index + 1) % depreciation->n;
+  } else {
+    // For a zero deprecitation time, take the value directly from the input.
+    result = input;
+  }
+  return result;
+}

package/src/c/vensim.h

@@ -26,6 +26,7 @@ extern "C" {
 #define _MAX(a, b) fmax(a, b)
 #define _MIN(a, b) fmin(a, b)
 #define _MODULO(a, b) fmod(a, b)
+#define _POWER(a, b) pow(a, b)
 #define _QUANTUM(a, b) ((b) <= 0 ? (a) : (b) * trunc((a) / (b)))
 #define _SAMPLE_IF_TRUE(current, condition, input) (bool_cond(condition) ? (input) : (current))
 #define _SIN(x) sin(x)
@@ -84,6 +85,20 @@ typedef struct {
 double _DELAY_FIXED(double input, FixedDelay* fixed_delay);
 FixedDelay* __new_fixed_delay(FixedDelay* fixed_delay, double delay_time, double initial_value);
 
+//
+// DEPRECIATE STRAIGHTLINE
+//
+typedef struct {
+  double* data;
+  size_t n;
+  size_t data_index;
+  double dtime;
+  double initial_value;
+} Depreciation;
+
+double _DEPRECIATE_STRAIGHTLINE(double input, Depreciation* depreciation);
+Depreciation* __new_depreciation(Depreciation* depreciation, double dtime, double initial_value);
+
 #ifdef __cplusplus
 }
 #endif