@diagrammo/dgmo 0.25.4 → 0.25.5

package/dist/pert.cjs

@@ -0,0 +1,325 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pert/index.ts
+var pert_exports = {};
+__export(pert_exports, {
+  buildSimulationContext: () => buildSimulationContext,
+  mulberry32: () => mulberry32,
+  sampleBetaPert: () => sampleBetaPert,
+  simulateCanonical: () => simulateCanonical,
+  simulateFast: () => simulateFast
+});
+module.exports = __toCommonJS(pert_exports);
+
+// src/pert/internal.ts
+var UNIT_TO_DAYS_LOCAL = {
+  min: 1 / (60 * 24),
+  h: 1 / 24,
+  d: 1,
+  bd: 1,
+  // PERT has no calendar; bd ≈ d for analytical purposes
+  w: 7,
+  m: 30,
+  q: 90,
+  y: 365,
+  s: 14
+  // sprint (14 calendar days) — not seconds
+};
+function unitToDays(unit) {
+  return UNIT_TO_DAYS_LOCAL[unit];
+}
+
+// src/pert/monte-carlo.ts
+function lagDays(lag) {
+  return lag === null ? 0 : lag.amount * unitToDays(lag.unit);
+}
+function mulberry32(seed) {
+  let s = seed >>> 0;
+  return () => {
+    s = s + 1831565813 >>> 0;
+    let t = s;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function standardNormal(rng) {
+  let u = 0;
+  let v = 0;
+  while (u === 0) u = rng();
+  while (v === 0) v = rng();
+  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+}
+function gamma(shape, rng) {
+  if (shape < 1) {
+    const u = rng();
+    return gamma(shape + 1, rng) * Math.pow(u, 1 / shape);
+  }
+  const d = shape - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  while (true) {
+    let x;
+    let v;
+    do {
+      x = standardNormal(rng);
+      v = 1 + c * x;
+    } while (v <= 0);
+    v = v * v * v;
+    const u = rng();
+    if (u < 1 - 0.0331 * x * x * x * x) return d * v;
+    if (Math.log(u) < x * x / 2 + d * (1 - v + Math.log(v))) return d * v;
+  }
+}
+function sampleBeta(alpha, beta, rng) {
+  const x = gamma(alpha, rng);
+  const y = gamma(beta, rng);
+  return x / (x + y);
+}
+function sampleBetaPert(o, m, p, rng) {
+  if (o === p) return m;
+  const range = p - o;
+  const alpha = 1 + 4 * (m - o) / range;
+  const beta = 1 + 4 * (p - m) / range;
+  return o + sampleBeta(alpha, beta, rng) * range;
+}
+function simulate(resolved, expanded, _predecessors, _successors, topo, terminals, poisoned, opts) {
+  const rng = mulberry32(opts.seed);
+  const expById = /* @__PURE__ */ new Map();
+  for (const e of expanded) expById.set(e.id, e);
+  const completionTimes = new Array(opts.trials);
+  const criticalityCount = /* @__PURE__ */ new Map();
+  for (const id of topo) criticalityCount.set(id, 0);
+  const pathCount = /* @__PURE__ */ new Map();
+  const pathById = /* @__PURE__ */ new Map();
+  const incomingEdges = /* @__PURE__ */ new Map();
+  for (const id of topo) incomingEdges.set(id, []);
+  for (const e of resolved.edges) incomingEdges.get(e.target)?.push(e);
+  const es = /* @__PURE__ */ new Map();
+  const ef = /* @__PURE__ */ new Map();
+  const predOnLongestPath = /* @__PURE__ */ new Map();
+  for (let trial = 0; trial < opts.trials; trial++) {
+    for (const id of topo) {
+      const exp = expById.get(id);
+      let duration;
+      if (!exp || poisoned.has(id)) {
+        duration = 0;
+      } else if (exp.o === exp.p) {
+        duration = exp.m;
+      } else {
+        duration = sampleBetaPert(exp.o, exp.m, exp.p, rng);
+      }
+      let esLower = 0;
+      let efLower = -Infinity;
+      let bestPred = null;
+      let bestPredVal = -Infinity;
+      for (const edge of incomingEdges.get(id) ?? []) {
+        const aEs = es.get(edge.source) ?? 0;
+        const aEf = ef.get(edge.source) ?? 0;
+        const lag = lagDays(edge.lag);
+        let candES = -Infinity;
+        let candEF = -Infinity;
+        switch (edge.type) {
+          case "FS":
+            candES = aEf + lag;
+            break;
+          case "SS":
+            candES = aEs + lag;
+            break;
+          case "FF":
+            candEF = aEf + lag;
+            break;
+          case "SF":
+            candEF = aEs + lag;
+            break;
+        }
+        if (candES > esLower) esLower = candES;
+        if (candEF > efLower) efLower = candEF;
+        const contribution = Math.max(candES, candEF - duration);
+        if (contribution > bestPredVal) {
+          bestPredVal = contribution;
+          bestPred = edge.source;
+        }
+      }
+      let esVal = esLower;
+      let efVal = esVal + duration;
+      if (efLower > efVal) {
+        efVal = efLower;
+        esVal = efVal - duration;
+      }
+      es.set(id, esVal);
+      ef.set(id, efVal);
+      predOnLongestPath.set(id, bestPred);
+    }
+    let endEf = 0;
+    let endId = terminals[0] ?? null;
+    for (const id of topo) {
+      const e = ef.get(id) ?? 0;
+      if (e > endEf) {
+        endEf = e;
+        endId = id;
+      }
+    }
+    completionTimes[trial] = endEf;
+    if (endId !== null) {
+      const path = [];
+      let cur = endId;
+      while (cur !== null) {
+        path.unshift(cur);
+        criticalityCount.set(cur, (criticalityCount.get(cur) ?? 0) + 1);
+        cur = predOnLongestPath.get(cur) ?? null;
+      }
+      const key = path.join("\0");
+      pathCount.set(key, (pathCount.get(key) ?? 0) + 1);
+      if (!pathById.has(key)) pathById.set(key, path);
+    }
+  }
+  completionTimes.sort((a, b) => a - b);
+  const pct = (frac) => {
+    const idx = Math.min(
+      completionTimes.length - 1,
+      Math.max(0, Math.floor(frac * completionTimes.length))
+    );
+    return completionTimes[idx] ?? 0;
+  };
+  const minDurationDays = completionTimes[0] ?? 0;
+  const maxDurationDays = completionTimes[completionTimes.length - 1] ?? 0;
+  let modalKey = "";
+  let modalCount = -1;
+  for (const [key, count] of pathCount) {
+    if (count > modalCount) {
+      modalCount = count;
+      modalKey = key;
+    } else if (count === modalCount) {
+      const a = pathById.get(modalKey) ?? [];
+      const b = pathById.get(key) ?? [];
+      const va = pathVariance(a, expById);
+      const vb = pathVariance(b, expById);
+      if (vb > va) {
+        modalKey = key;
+      } else if (vb === va && key.localeCompare(modalKey) < 0) {
+        modalKey = key;
+      }
+    }
+  }
+  const criticalityByActivity = {};
+  for (const id of topo) {
+    criticalityByActivity[id] = (criticalityCount.get(id) ?? 0) / opts.trials;
+  }
+  return {
+    trials: opts.trials,
+    seed: opts.seed,
+    p50: pct(0.5),
+    p80: pct(0.8),
+    p95: pct(0.95),
+    p16: pct(0.16),
+    p84: pct(0.84),
+    criticalityByActivity,
+    modalCriticalPath: pathById.get(modalKey) ?? [],
+    // Analyzer populates this after MC returns by running the
+    // deterministic per-activity tornado pass. Empty here so the
+    // type contract is satisfied even in scrubber/fast paths that
+    // never compute swings.
+    tornadoSwings: [],
+    minDurationDays,
+    maxDurationDays
+  };
+}
+function pathVariance(path, expById) {
+  let sum = 0;
+  for (const id of path) {
+    const e = expById.get(id);
+    if (!e) continue;
+    const sigma = (e.p - e.o) / 6;
+    sum += sigma * sigma;
+  }
+  return sum;
+}
+function buildSimulationContext(resolved) {
+  const predecessors = /* @__PURE__ */ new Map();
+  const successors = /* @__PURE__ */ new Map();
+  for (const r of resolved.activities) {
+    predecessors.set(r.activity.id, []);
+    successors.set(r.activity.id, []);
+  }
+  for (const e of resolved.edges) {
+    successors.get(e.source)?.push(e.target);
+    predecessors.get(e.target)?.push(e.source);
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const r of resolved.activities) {
+    inDegree.set(r.activity.id, predecessors.get(r.activity.id).length);
+  }
+  const queue = [];
+  for (const [id, deg] of inDegree) if (deg === 0) queue.push(id);
+  const topo = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    topo.push(id);
+    for (const next of successors.get(id) ?? []) {
+      const deg = (inDegree.get(next) ?? 0) - 1;
+      inDegree.set(next, deg);
+      if (deg === 0) queue.push(next);
+    }
+  }
+  const terminals = [];
+  for (const r of resolved.activities) {
+    if ((successors.get(r.activity.id) ?? []).length === 0) {
+      terminals.push(r.activity.id);
+    }
+  }
+  const poisoned = /* @__PURE__ */ new Set();
+  for (const r of resolved.activities) {
+    if (r.activity.duration === null) {
+      const stack = [r.activity.id];
+      while (stack.length > 0) {
+        const id = stack.pop();
+        if (poisoned.has(id)) continue;
+        poisoned.add(id);
+        for (const next of successors.get(id) ?? []) stack.push(next);
+      }
+    }
+  }
+  return { predecessors, successors, topo, terminals, poisoned };
+}
+function simulateCanonical(resolved, expanded, opts) {
+  const ctx = buildSimulationContext(resolved);
+  return simulate(
+    resolved,
+    expanded,
+    ctx.predecessors,
+    ctx.successors,
+    ctx.topo,
+    ctx.terminals,
+    ctx.poisoned,
+    { trials: opts.trials, seed: opts.seed }
+  );
+}
+function simulateFast(resolved, expanded, opts) {
+  return simulateCanonical(resolved, expanded, opts);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildSimulationContext,
+  mulberry32,
+  sampleBetaPert,
+  simulateCanonical,
+  simulateFast
+});
+//# sourceMappingURL=pert.cjs.map