@sdeverywhere/cli 0.7.41 → 0.7.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/cli",
-  "version": "0.7.41",
+  "version": "0.7.42",
   "description": "Contains the `sde` command line interface for the SDEverywhere tool suite.",
   "type": "module",
   "files": [
@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "@sdeverywhere/build": "^0.3.12",
-    "@sdeverywhere/compile": "^0.7.29",
+    "@sdeverywhere/compile": "^0.7.30",
     "byline": "^5.0.0",
     "ramda": "^0.27.0",
     "shelljs": "^0.10.0",

package/src/c/vensim.c

@@ -503,6 +503,237 @@ double* _ALLOCATE_AVAILABLE(
   return allocations;
 }
 
+//
+// Helper methods for allocate by priority
+//
+double __sum(double* arr, size_t n) {
+  double total = 0.0;
+  for (size_t i = 0; i < n; i++) {
+    total += arr[i];
+  }
+  return total;
+}
+
+// 
+// ALLOCATE BY PRIORITY
+//
+#define ALLOCATE_BY_PRIORITY_BUFSIZE 60
+#define PRINT_ALLOCATIONS_DEBUG_INFO
+
+double* _ALLOCATE_BY_PRIORITY(
+  double* request_quantities, double* priority_values, double size, double width, double supply, size_t num_requesters) {
+
+  // request points to an array of length num_requesters.
+  // priority points to an array of length num_requesters.
+  // size is the number of elements across which allocation is being made.
+  // width specifies how big a gap in priority is required to have the allocation go first to 
+  //    higher priority with only leftovers going to lower priority. 
+  // supply is the total supply available to fulfill all requests.
+
+  // Allocate by priority allocates supply to requesters based on order of priority. The way in 
+  // which the rationing works is determined by the relative priorities and the width parameter.
+
+  static double allocations[ALLOCATE_BY_PRIORITY_BUFSIZE];
+  if (num_requesters > ALLOCATE_BY_PRIORITY_BUFSIZE) {
+    fprintf(stderr, "_ALLOCATE_BY_PRIORITY num_requesters exceeds internal maximum size of %d\n", ALLOCATE_BY_PRIORITY_BUFSIZE);
+    return NULL;
+  }
+
+  // Validate request values (must be non-negative)
+  for (size_t i = 0; i < num_requesters; i++) {
+    if (request_quantities[i] < -_epsilon) {
+      fprintf(stderr,
+          "_ALLOCATE_BY_PRIORITY encountered negative request value at index %zu: %f\n",
+          i, request_quantities[i]);
+      return NULL;
+    }
+  }
+
+  // Validate width (must not be negative)
+  if (width < -_epsilon) {
+    fprintf(stderr,
+        "_ALLOCATE_BY_PRIORITY encountered invalid width value: %f\n"
+        "Width must not be negative.\n",
+        width);
+    return NULL;
+  }
+
+  // Validate supply (must not be negative)
+  if (supply < -_epsilon) {
+    fprintf(stderr,
+        "_ALLOCATE_BY_PRIORITY encountered invalid supply value: %f\n"
+        "Supply must not be negative.\n",
+        supply);
+    return NULL;
+  }
+
+  // If supply > sum(request), return request
+  if (supply > __sum(request_quantities, num_requesters)) {
+    return request_quantities;
+  }
+
+  // If supply = 0, all targets get allocated 0
+  if(fabs(supply) < _epsilon) {
+    return allocations;
+  }
+
+  static double out_return[ALLOCATE_BY_PRIORITY_BUFSIZE];
+
+  // Remove request 0 targets and order by priority
+  bool is_0[ALLOCATE_BY_PRIORITY_BUFSIZE];
+  size_t idx[ALLOCATE_BY_PRIORITY_BUFSIZE];
+  size_t m = 0;
+
+  for (size_t i = 0; i < num_requesters; i++) {
+    is_0[i] = request_quantities[i] == 0.0;
+    if (!is_0[i]) {
+      idx[m++] = i;
+    }
+  }
+
+  // Sort indices in `idx` by descending `priority_values` (highest priority first)
+  for (size_t i = 0; i < m; i++) {
+    for (size_t j = i + 1; j < m; j++) {
+      if (priority_values[idx[j]] > priority_values[idx[i]]) {
+        size_t tmp = idx[i];
+        idx[i] = idx[j];
+        idx[j] = tmp;
+      }
+    }
+  }
+
+  // Populate local arrays with request and priority values reordered according to idx
+  double request[ALLOCATE_BY_PRIORITY_BUFSIZE];
+  double priority[ALLOCATE_BY_PRIORITY_BUFSIZE];
+
+  for (size_t i = 0; i < m; i++) {
+    request[i] = (double)request_quantities[idx[i]];
+    priority[i] = priority_values[idx[i]];
+  }
+
+  // Create the outputs array
+  for (size_t i = 0; i < num_requesters; i++) {
+    out_return[i] = 0.0;
+  }
+
+  double out[ALLOCATE_BY_PRIORITY_BUFSIZE] = {0.0};
+
+  // Compute the distances between target supply and next target start
+  double distances[ALLOCATE_BY_PRIORITY_BUFSIZE];
+
+  for (size_t i = 0; i < m; i++) {
+    distances[i] = NAN;
+  }
+
+  // Last target will have NaN as distances as there are no more targets after
+  for (size_t i = 0; i + 1 < m; i++) {
+    double d = -(priority[i + 1] - priority[i]) / width;
+    if (d > 1.0) d = 1.0;
+    distances[i] = d * request[i];
+  }
+
+  // Index of the current activated target
+  bool active[ALLOCATE_BY_PRIORITY_BUFSIZE] = {false};
+  active[0] = true;
+
+  // Index of the last activated target
+  size_t c_i = 0;
+
+  // Continue allocating until supply is exhausted
+  while (supply > _epsilon) {
+    // Check if there are any active targets left
+    bool any_active = false;
+    for (size_t i = 0; i < m; i++) {
+      if (active[i]) {
+        any_active = true;
+        break;
+      }
+    }
+    if (!any_active) {
+      break;
+    }
+
+    // Compute proportional allocation weights ("slopes") for active targets
+    double slopes[ALLOCATE_BY_PRIORITY_BUFSIZE];
+    double slope_sum = 0.0;
+
+    for (size_t i = 0; i < m; i++) {
+      if (active[i]) {
+        slopes[i] = request[i]; // weight based on requested amount
+        slope_sum += slopes[i];
+      } else {
+        slopes[i] = 0.0;
+      }
+    }
+
+    // Normalize slopes so total allocation proportion sums to 1
+    for (size_t i = 0; i < m; i++) {
+      slopes[i] /= slope_sum;
+    }
+
+    // Compute how much supply much be given to any target reach its request
+    double dx_next_top = NAN;
+
+    for (size_t i = 0; i < m; i++) {
+      if (active[i]) {
+        double val = (request[i] - out[i]) / slopes[i];
+        if (isnan(dx_next_top) || val < dx_next_top) {
+          dx_next_top = val;
+        }
+      }
+    }
+
+    // Compute how much supply is needed to activate the next target
+    // (last target will return nan)
+    double dx_next_start = (distances[c_i] - out[c_i]) / slopes[c_i];
+
+    // Determine next allocation step size:
+    // smallest of (next completion, next activation, remaining supply)
+    double dx = dx_next_top;
+
+    if (!isnan(dx_next_start) && dx_next_start < dx) {
+      dx = dx_next_start;
+    }
+    if (supply < dx) {
+      dx = supply;
+    }
+
+    // Distribute this increment of supply across active targets
+    for (size_t i = 0; i < m; i++) {
+      out[i] += slopes[i] * dx;
+    }
+
+    // If we reached the threshold to activate the next target
+    if (fabs(dx - dx_next_start) <= (1e-10 * fabs(dx_next_start) + 1e-16)) {
+      // A new target will start in the next loop
+      c_i++;
+
+      // Active the next targetif its request is different than 0
+      if (c_i < m) active[c_i] = true;
+    }
+
+    // If any targets have reached their requested amount, deactivate them
+    if (dx == dx_next_top) {
+      for (size_t i = 0; i < m; i++) {
+        if (fabs(out[i] - request[i]) <= 1e-12) {
+          active[i] = false;
+        }
+      }
+    }
+
+    // Reduce remaining supply
+    supply -= dx;
+  }
+
+  // Return the distributed supply in the original order
+  // adding to it again the request 0 if the where removed
+  for (size_t i = 0; i < m; i++) {
+    out_return[idx[i]] = out[i];
+  }
+
+  return out_return;
+}
+
 //
 // DELAY FIXED
 //

package/src/c/vensim.h

@@ -39,6 +39,7 @@ extern "C" {
 
 
 double* _ALLOCATE_AVAILABLE(double* requested_quantities, double* priority_profiles, double available_resource, size_t num_requesters);
+double* _ALLOCATE_BY_PRIORITY(double* request, double* priority, double size, double width, double supply, size_t num_requesters);
 double _PULSE(double start, double width);
 double _PULSE_TRAIN(double start, double width, double interval, double end);
 double _RAMP(double slope, double start_time, double end_time);