@almadar/evaluator 2.0.0 → 2.1.0

package/dist/{index-csemIxy4.d.ts → index-DBM7Xkm3.d.ts}

@@ -49,6 +49,19 @@ interface EvaluationContext {
      * Helps detect typos and missing entity fields early.
      */
     strictBindings?: boolean;
+    /**
+     * Set by prob/condition when a predicate fails during inference.
+     * Checked by prob/posterior and prob/infer to reject samples.
+     */
+    _probRejected?: boolean;
+    /**
+     * Seeded PRNG state for deterministic probabilistic sampling.
+     * Stored as a mutable object so child contexts share the same state.
+     * Set by prob/seed.
+     */
+    _probSeed?: {
+        state: number;
+    };
     /** Mutate entity fields */
     mutateEntity?: (changes: Record<string, unknown>) => void;
     /** Emit an event */

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { SExpr } from '@almadar/core';
 export { CORE_BINDINGS, CoreBinding, Expression, ExpressionSchema, ParsedBinding, SExpr, SExprAtom, SExprSchema, collectBindings, getArgs, getOperator, isBinding, isSExpr, isSExprAtom, isSExprCall, isValidBinding, parseBinding, sexpr, walkSExpr } from '@almadar/core';
-import { E as EvaluationContext } from './index-csemIxy4.js';
-export { c as createChildContext, a as createEffectContext, b as createMinimalContext, e as evalAbs, d as evalAdd, f as evalAnd, g as evalCallService, h as evalCeil, i as evalClamp, j as evalConcat, k as evalCount, l as evalDecrement, m as evalDespawn, n as evalDivide, o as evalDo, p as evalEmit, q as evalEmpty, r as evalEqual, s as evalFilter, t as evalFind, u as evalFirst, v as evalFloor, w as evalFn, x as evalGreaterThan, y as evalGreaterThanOrEqual, z as evalIf, A as evalIncludes, B as evalIncrement, C as evalLast, D as evalLessThan, F as evalLessThanOrEqual, G as evalLet, H as evalMap, I as evalMatches, J as evalMax, K as evalMin, L as evalModulo, M as evalMultiply, N as evalNavigate, O as evalNot, P as evalNotEqual, Q as evalNotify, R as evalNth, S as evalOr, T as evalPersist, U as evalRenderUI, V as evalRound, W as evalSet, X as evalSetDynamic, Y as evalSpawn, Z as evalSubtract, _ as evalSum, $ as evalWhen, a0 as resolveBinding } from './index-csemIxy4.js';
+import { E as EvaluationContext } from './index-DBM7Xkm3.js';
+export { c as createChildContext, a as createEffectContext, b as createMinimalContext, e as evalAbs, d as evalAdd, f as evalAnd, g as evalCallService, h as evalCeil, i as evalClamp, j as evalConcat, k as evalCount, l as evalDecrement, m as evalDespawn, n as evalDivide, o as evalDo, p as evalEmit, q as evalEmpty, r as evalEqual, s as evalFilter, t as evalFind, u as evalFirst, v as evalFloor, w as evalFn, x as evalGreaterThan, y as evalGreaterThanOrEqual, z as evalIf, A as evalIncludes, B as evalIncrement, C as evalLast, D as evalLessThan, F as evalLessThanOrEqual, G as evalLet, H as evalMap, I as evalMatches, J as evalMax, K as evalMin, L as evalModulo, M as evalMultiply, N as evalNavigate, O as evalNot, P as evalNotEqual, Q as evalNotify, R as evalNth, S as evalOr, T as evalPersist, U as evalRenderUI, V as evalRound, W as evalSet, X as evalSetDynamic, Y as evalSpawn, Z as evalSubtract, _ as evalSum, $ as evalWhen, a0 as resolveBinding } from './index-DBM7Xkm3.js';
 
 /**
  * S-Expression Evaluator

package/dist/index.js

@@ -2101,6 +2101,224 @@ async function evalAsyncSequence(args, evaluate2, ctx) {
   return results;
 }
 
+// std/prob.ts
+function mulberry32(seed) {
+  let t = seed.state += 1831565813;
+  t = Math.imul(t ^ t >>> 15, t | 1);
+  t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+  return ((t ^ t >>> 14) >>> 0) / 4294967296;
+}
+function getRandom(ctx) {
+  if (ctx._probSeed) {
+    return mulberry32(ctx._probSeed);
+  }
+  return Math.random();
+}
+function gammaVariate(shape, ctx) {
+  if (shape < 1) {
+    const u = getRandom(ctx);
+    return gammaVariate(shape + 1, ctx) * Math.pow(u, 1 / shape);
+  }
+  const d = shape - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  for (; ; ) {
+    let x;
+    let v;
+    do {
+      x = gaussianStandard(ctx);
+      v = 1 + c * x;
+    } while (v <= 0);
+    v = v * v * v;
+    const u = getRandom(ctx);
+    if (u < 1 - 0.0331 * (x * x) * (x * x)) {
+      return d * v;
+    }
+    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) {
+      return d * v;
+    }
+  }
+}
+function gaussianStandard(ctx) {
+  const u1 = getRandom(ctx);
+  const u2 = getRandom(ctx);
+  return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+function evalProbSeed(args, evaluate2, ctx) {
+  const n = evaluate2(args[0], ctx);
+  ctx._probSeed = { state: n | 0 };
+}
+function evalProbFlip(args, evaluate2, ctx) {
+  const p = evaluate2(args[0], ctx);
+  return getRandom(ctx) < p;
+}
+function evalProbGaussian(args, evaluate2, ctx) {
+  const mu = evaluate2(args[0], ctx);
+  const sigma = evaluate2(args[1], ctx);
+  return mu + sigma * gaussianStandard(ctx);
+}
+function evalProbUniform(args, evaluate2, ctx) {
+  const lo = evaluate2(args[0], ctx);
+  const hi = evaluate2(args[1], ctx);
+  return lo + getRandom(ctx) * (hi - lo);
+}
+function evalProbBeta(args, evaluate2, ctx) {
+  const alpha = evaluate2(args[0], ctx);
+  const beta = evaluate2(args[1], ctx);
+  const x = gammaVariate(alpha, ctx);
+  const y = gammaVariate(beta, ctx);
+  return x / (x + y);
+}
+function evalProbCategorical(args, evaluate2, ctx) {
+  const items = evaluate2(args[0], ctx);
+  const weights = evaluate2(args[1], ctx);
+  const totalWeight = weights.reduce((sum, w) => sum + w, 0);
+  let r = getRandom(ctx) * totalWeight;
+  for (let i = 0; i < items.length; i++) {
+    r -= weights[i];
+    if (r <= 0) return items[i];
+  }
+  return items[items.length - 1];
+}
+function evalProbPoisson(args, evaluate2, ctx) {
+  const lambda = evaluate2(args[0], ctx);
+  const limit = Math.exp(-lambda);
+  let k = 0;
+  let p = 1;
+  do {
+    k++;
+    p *= getRandom(ctx);
+  } while (p > limit);
+  return k - 1;
+}
+function evalProbCondition(args, evaluate2, ctx) {
+  const predicate = evaluate2(args[0], ctx);
+  if (!predicate) {
+    ctx._probRejected = true;
+  }
+}
+function evalProbSample(args, evaluate2, ctx) {
+  const n = evaluate2(args[0], ctx);
+  const exprAst = args[1];
+  const results = [];
+  for (let i = 0; i < n; i++) {
+    results.push(evaluate2(exprAst, ctx));
+  }
+  return results;
+}
+function evalProbPosterior(args, evaluate2, ctx) {
+  const modelAst = args[0];
+  const evidenceAst = args[1];
+  const queryAst = args[2];
+  const n = evaluate2(args[3], ctx);
+  const results = [];
+  for (let i = 0; i < n; i++) {
+    const sampleEntity = { ...ctx.entity };
+    const sampleCtx = {
+      ...ctx,
+      entity: sampleEntity,
+      _probRejected: false,
+      mutateEntity: (changes) => {
+        Object.assign(sampleEntity, changes);
+      }
+    };
+    evaluate2(modelAst, sampleCtx);
+    if (sampleCtx._probRejected) continue;
+    const evidenceResult = evaluate2(evidenceAst, sampleCtx);
+    if (!evidenceResult) continue;
+    results.push(evaluate2(queryAst, sampleCtx));
+  }
+  return results;
+}
+function evalProbInfer(args, evaluate2, ctx) {
+  const modelAst = args[0];
+  const evidenceAst = args[1];
+  const queryAst = args[2];
+  const n = evaluate2(args[3], ctx);
+  const accepted = [];
+  for (let i = 0; i < n; i++) {
+    const sampleEntity = { ...ctx.entity };
+    const sampleCtx = {
+      ...ctx,
+      entity: sampleEntity,
+      _probRejected: false,
+      mutateEntity: (changes) => {
+        Object.assign(sampleEntity, changes);
+      }
+    };
+    evaluate2(modelAst, sampleCtx);
+    if (sampleCtx._probRejected) continue;
+    const evidenceResult = evaluate2(evidenceAst, sampleCtx);
+    if (!evidenceResult) continue;
+    const queryVal = evaluate2(queryAst, sampleCtx);
+    accepted.push(queryVal);
+  }
+  const count = accepted.length;
+  if (count === 0) {
+    return { mean: 0, variance: 0, samples: [], acceptRate: 0 };
+  }
+  const mean = accepted.reduce((s, v) => s + v, 0) / count;
+  const variance = accepted.reduce((s, v) => s + (v - mean) ** 2, 0) / count;
+  return {
+    mean,
+    variance,
+    samples: accepted,
+    acceptRate: count / n
+  };
+}
+function evalProbExpectedValue(args, evaluate2, ctx) {
+  const samples = evaluate2(args[0], ctx);
+  if (samples.length === 0) return 0;
+  return samples.reduce((s, v) => s + v, 0) / samples.length;
+}
+function evalProbVariance(args, evaluate2, ctx) {
+  const samples = evaluate2(args[0], ctx);
+  if (samples.length === 0) return 0;
+  const mean = samples.reduce((s, v) => s + v, 0) / samples.length;
+  return samples.reduce((s, v) => s + (v - mean) ** 2, 0) / samples.length;
+}
+function evalProbHistogram(args, evaluate2, ctx) {
+  const samples = evaluate2(args[0], ctx);
+  const bins = evaluate2(args[1], ctx);
+  if (samples.length === 0) {
+    return { binEdges: [], counts: [] };
+  }
+  const min = Math.min(...samples);
+  const max = Math.max(...samples);
+  const binWidth = (max - min) / bins || 1;
+  const binEdges = [];
+  const counts = new Array(bins).fill(0);
+  for (let i = 0; i <= bins; i++) {
+    binEdges.push(min + i * binWidth);
+  }
+  for (const s of samples) {
+    let idx = Math.floor((s - min) / binWidth);
+    if (idx >= bins) idx = bins - 1;
+    counts[idx]++;
+  }
+  return { binEdges, counts };
+}
+function evalProbPercentile(args, evaluate2, ctx) {
+  const samples = evaluate2(args[0], ctx);
+  const p = evaluate2(args[1], ctx);
+  if (samples.length === 0) return 0;
+  const sorted = [...samples].sort((a, b) => a - b);
+  const idx = p / 100 * (sorted.length - 1);
+  const lo = Math.floor(idx);
+  const hi = Math.ceil(idx);
+  if (lo === hi) return sorted[lo];
+  const frac = idx - lo;
+  return sorted[lo] * (1 - frac) + sorted[hi] * frac;
+}
+function evalProbCredibleInterval(args, evaluate2, ctx) {
+  const samples = evaluate2(args[0], ctx);
+  const alpha = evaluate2(args[1], ctx);
+  if (samples.length === 0) return [0, 0];
+  const sorted = [...samples].sort((a, b) => a - b);
+  const loIdx = Math.floor(alpha / 2 * (sorted.length - 1));
+  const hiIdx = Math.ceil((1 - alpha / 2) * (sorted.length - 1));
+  return [sorted[loIdx], sorted[hiIdx]];
+}
+
 // SExpressionEvaluator.ts
 var jitCache = /* @__PURE__ */ new Map();
 var MAX_JIT_CACHE_SIZE = 1e3;
@@ -2666,6 +2884,43 @@ var SExpressionEvaluator = class {
         return evalAsyncAll(args, evaluate2, ctx);
       case "async/sequence":
         return evalAsyncSequence(args, evaluate2, ctx);
+      // ===============================
+      // Standard Library: prob/*
+      // ===============================
+      case "prob/seed":
+        evalProbSeed(args, evaluate2, ctx);
+        return void 0;
+      case "prob/flip":
+        return evalProbFlip(args, evaluate2, ctx);
+      case "prob/gaussian":
+        return evalProbGaussian(args, evaluate2, ctx);
+      case "prob/uniform":
+        return evalProbUniform(args, evaluate2, ctx);
+      case "prob/beta":
+        return evalProbBeta(args, evaluate2, ctx);
+      case "prob/categorical":
+        return evalProbCategorical(args, evaluate2, ctx);
+      case "prob/poisson":
+        return evalProbPoisson(args, evaluate2, ctx);
+      case "prob/condition":
+        evalProbCondition(args, evaluate2, ctx);
+        return void 0;
+      case "prob/sample":
+        return evalProbSample(args, evaluate2, ctx);
+      case "prob/posterior":
+        return evalProbPosterior(args, evaluate2, ctx);
+      case "prob/infer":
+        return evalProbInfer(args, evaluate2, ctx);
+      case "prob/expected-value":
+        return evalProbExpectedValue(args, evaluate2, ctx);
+      case "prob/variance":
+        return evalProbVariance(args, evaluate2, ctx);
+      case "prob/histogram":
+        return evalProbHistogram(args, evaluate2, ctx);
+      case "prob/percentile":
+        return evalProbPercentile(args, evaluate2, ctx);
+      case "prob/credible-interval":
+        return evalProbCredibleInterval(args, evaluate2, ctx);
       default:
         console.warn(`Unknown operator: ${op}`);
         return void 0;