@holoscript/std 2.1.0 → 6.0.3

package/src/__tests__/SimulationLabPrimitives.test.ts

@@ -0,0 +1,415 @@
+import { describe, it, expect } from 'vitest';
+import {
+  mean,
+  variance,
+  standardDeviation,
+  standardError,
+  cohensD,
+  tTest,
+  oneSampleTTest,
+  mannWhitneyU,
+  chiSquaredTest,
+  expandSweep,
+  generateSweepCombinations,
+  extractMetric,
+  groupByParameter,
+  summarizeMetrics,
+  isParameterRange,
+} from '../traits/SimulationLabPrimitives.js';
+import type {
+  ParameterRange,
+  ParameterSet,
+  SimulationMetrics,
+} from '../traits/SimulationLabPrimitives.js';
+import {
+  SimulationLabTraits,
+  getSimulationTraitNames,
+  getSimulationTrait,
+} from '../traits/SimulationLabTraits.js';
+
+// =============================================================================
+// BASIC STATISTICS
+// =============================================================================
+
+describe('Basic Statistics', () => {
+  describe('mean', () => {
+    it('should return 0 for empty array', () => {
+      expect(mean([])).toBe(0);
+    });
+    it('should calculate correct mean', () => {
+      expect(mean([1, 2, 3, 4, 5])).toBe(3);
+    });
+    it('should handle single element', () => {
+      expect(mean([42])).toBe(42);
+    });
+    it('should handle negative numbers', () => {
+      expect(mean([-10, 10])).toBe(0);
+    });
+  });
+
+  describe('variance', () => {
+    it('should return 0 for single element', () => {
+      expect(variance([5])).toBe(0);
+    });
+    it('should return 0 for identical values', () => {
+      expect(variance([3, 3, 3, 3])).toBe(0);
+    });
+    it('should calculate sample variance with Bessel correction', () => {
+      // [1,2,3,4,5]: mean=3, sum of sq diffs=10, n-1=4 -> var=2.5
+      expect(variance([1, 2, 3, 4, 5])).toBe(2.5);
+    });
+  });
+
+  describe('standardDeviation', () => {
+    it('should be sqrt of variance', () => {
+      const data = [1, 2, 3, 4, 5];
+      expect(standardDeviation(data)).toBeCloseTo(Math.sqrt(2.5), 10);
+    });
+  });
+
+  describe('standardError', () => {
+    it('should return 0 for empty array', () => {
+      expect(standardError([])).toBe(0);
+    });
+    it('should equal sd / sqrt(n)', () => {
+      const data = [1, 2, 3, 4, 5];
+      const sd = standardDeviation(data);
+      expect(standardError(data)).toBeCloseTo(sd / Math.sqrt(5), 10);
+    });
+  });
+
+  describe('cohensD', () => {
+    it('should return 0 for identical groups', () => {
+      expect(cohensD([5, 5, 5], [5, 5, 5])).toBe(0);
+    });
+    it('should return positive d when group1 > group2', () => {
+      const d = cohensD([10, 11, 12], [1, 2, 3]);
+      expect(d).toBeGreaterThan(0);
+    });
+    it('should return large d for well-separated groups', () => {
+      const d = cohensD([100, 101, 102], [1, 2, 3]);
+      expect(Math.abs(d)).toBeGreaterThan(2); // Large effect
+    });
+    it('should handle insufficient data', () => {
+      expect(cohensD([5], [3])).toBe(0);
+    });
+  });
+});
+
+// =============================================================================
+// PARAMETER SWEEP
+// =============================================================================
+
+describe('Parameter Sweep', () => {
+  describe('isParameterRange', () => {
+    it('should identify range', () => {
+      const r: ParameterRange = { name: 'x', min: 0, max: 10, step: 1 };
+      expect(isParameterRange(r)).toBe(true);
+    });
+    it('should reject set', () => {
+      const s: ParameterSet = { name: 'x', values: [1, 2, 3] };
+      expect(isParameterRange(s)).toBe(false);
+    });
+  });
+
+  describe('expandSweep', () => {
+    it('should expand range correctly', () => {
+      const r: ParameterRange = { name: 'x', min: 0, max: 1, step: 0.5 };
+      const values = expandSweep(r);
+      expect(values).toEqual([0, 0.5, 1.0]);
+    });
+    it('should return values for discrete set', () => {
+      const s: ParameterSet = { name: 'x', values: [1, 5, 10] };
+      expect(expandSweep(s)).toEqual([1, 5, 10]);
+    });
+    it('should handle zero step', () => {
+      const r: ParameterRange = { name: 'x', min: 5, max: 10, step: 0 };
+      expect(expandSweep(r)).toEqual([5]);
+    });
+    it('should handle reversed range', () => {
+      const r: ParameterRange = { name: 'x', min: 10, max: 5, step: 1 };
+      expect(expandSweep(r)).toEqual([]);
+    });
+    it('should handle single-value range', () => {
+      const r: ParameterRange = { name: 'x', min: 5, max: 5, step: 1 };
+      expect(expandSweep(r)).toEqual([5]);
+    });
+  });
+
+  describe('generateSweepCombinations', () => {
+    it('should return [{}] for empty sweeps', () => {
+      expect(generateSweepCombinations([])).toEqual([{}]);
+    });
+    it('should generate all values for single sweep', () => {
+      const combos = generateSweepCombinations([{ name: 'x', values: [1, 2, 3] }]);
+      expect(combos).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }]);
+    });
+    it('should generate Cartesian product for two sweeps', () => {
+      const combos = generateSweepCombinations([
+        { name: 'x', values: [1, 2] },
+        { name: 'y', values: [10, 20] },
+      ]);
+      expect(combos).toHaveLength(4);
+      expect(combos).toContainEqual({ x: 1, y: 10 });
+      expect(combos).toContainEqual({ x: 1, y: 20 });
+      expect(combos).toContainEqual({ x: 2, y: 10 });
+      expect(combos).toContainEqual({ x: 2, y: 20 });
+    });
+    it('should handle three sweeps', () => {
+      const combos = generateSweepCombinations([
+        { name: 'a', values: [1, 2] },
+        { name: 'b', values: [3, 4] },
+        { name: 'c', values: [5, 6] },
+      ]);
+      expect(combos).toHaveLength(8); // 2 * 2 * 2
+    });
+  });
+});
+
+// =============================================================================
+// STATISTICAL TESTS
+// =============================================================================
+
+describe('Statistical Tests', () => {
+  describe('tTest (Welch)', () => {
+    it('should detect significantly different means', () => {
+      const group1 = Array.from({ length: 100 }, (_, i) => 100 + Math.sin(i));
+      const group2 = Array.from({ length: 100 }, (_, i) => 50 + Math.sin(i));
+      const result = tTest(group1, group2);
+      expect(result.significant).toBe(true);
+      expect(result.pValue).toBeLessThan(0.05);
+      expect(result.testName).toBe('welch_t_test');
+    });
+
+    it('should NOT detect difference in identical groups', () => {
+      const data = Array.from({ length: 50 }, (_, i) => Math.sin(i) * 10);
+      const result = tTest(data, data);
+      expect(result.significant).toBe(false);
+      expect(result.pValue).toBeGreaterThan(0.05);
+    });
+
+    it('should handle small samples gracefully', () => {
+      const result = tTest([1], [2]);
+      expect(result.pValue).toBe(1);
+      expect(result.significant).toBe(false);
+    });
+
+    it('should report positive effect size when group1 > group2', () => {
+      const g1 = [100, 110, 120, 130, 140];
+      const g2 = [10, 20, 30, 40, 50];
+      const result = tTest(g1, g2);
+      expect(result.effectSize).toBeGreaterThan(0);
+    });
+
+    it('should respect directional hypotheses', () => {
+      const high = Array.from({ length: 50 }, () => 100 + Math.random() * 5);
+      const low = Array.from({ length: 50 }, () => 50 + Math.random() * 5);
+      const greater = tTest(high, low, 0.05, 'greater');
+      const less = tTest(high, low, 0.05, 'less');
+      expect(greater.pValue).toBeLessThan(less.pValue);
+    });
+  });
+
+  describe('oneSampleTTest', () => {
+    it('should detect mean different from population', () => {
+      const data = Array.from({ length: 100 }, (_, i) => 50 + Math.sin(i));
+      const result = oneSampleTTest(data, 0);
+      expect(result.significant).toBe(true);
+      expect(result.testName).toBe('one_sample_t_test');
+    });
+
+    it('should NOT reject when sample comes from population', () => {
+      // Data centered around 100
+      const data = Array.from({ length: 100 }, (_, i) => 100 + Math.sin(i) * 0.01);
+      const result = oneSampleTTest(data, 100);
+      expect(result.significant).toBe(false);
+    });
+  });
+
+  describe('mannWhitneyU', () => {
+    it('should detect difference in ranked groups', () => {
+      const high = [90, 91, 92, 93, 94, 95, 96, 97, 98, 99];
+      const low = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+      const result = mannWhitneyU(high, low);
+      expect(result.significant).toBe(true);
+      expect(result.testName).toBe('mann_whitney_u');
+    });
+
+    it('should handle empty groups', () => {
+      const result = mannWhitneyU([], [1, 2, 3]);
+      expect(result.significant).toBe(false);
+      expect(result.pValue).toBe(1);
+    });
+
+    it('should report effect size', () => {
+      const high = [90, 91, 92, 93, 94];
+      const low = [1, 2, 3, 4, 5];
+      const result = mannWhitneyU(high, low);
+      expect(Math.abs(result.effectSize)).toBeGreaterThan(0.5);
+    });
+  });
+
+  describe('chiSquaredTest', () => {
+    it('should NOT reject when observed matches expected', () => {
+      const observed = [50, 50, 50, 50];
+      const expected = [50, 50, 50, 50];
+      const result = chiSquaredTest(observed, expected);
+      expect(result.significant).toBe(false);
+      expect(result.statistic).toBe(0);
+    });
+
+    it('should reject when observed differs significantly from expected', () => {
+      const observed = [100, 10, 10, 10];
+      const expected = [32.5, 32.5, 32.5, 32.5];
+      const result = chiSquaredTest(observed, expected);
+      expect(result.significant).toBe(true);
+    });
+
+    it('should handle mismatched lengths', () => {
+      const result = chiSquaredTest([1, 2], [1]);
+      expect(result.significant).toBe(false);
+      expect(result.sampleSize).toBe(0);
+    });
+
+    it('should calculate Cramers V effect size', () => {
+      const observed = [100, 10, 10, 10];
+      const expected = [32.5, 32.5, 32.5, 32.5];
+      const result = chiSquaredTest(observed, expected);
+      expect(result.effectSize).toBeGreaterThan(0);
+    });
+  });
+});
+
+// =============================================================================
+// METRIC AGGREGATION
+// =============================================================================
+
+describe('Metric Aggregation', () => {
+  const mockMetrics: SimulationMetrics[] = [
+    { values: { score: 100, time: 5 }, seed: 1, params: { difficulty: 1 }, durationMs: 10 },
+    { values: { score: 120, time: 6 }, seed: 2, params: { difficulty: 1 }, durationMs: 12 },
+    { values: { score: 80, time: 8 }, seed: 3, params: { difficulty: 2 }, durationMs: 15 },
+    { values: { score: 70, time: 9 }, seed: 4, params: { difficulty: 2 }, durationMs: 14 },
+  ];
+
+  describe('extractMetric', () => {
+    it('should extract named metric values', () => {
+      expect(extractMetric(mockMetrics, 'score')).toEqual([100, 120, 80, 70]);
+    });
+    it('should return empty for unknown metric', () => {
+      expect(extractMetric(mockMetrics, 'unknown')).toEqual([]);
+    });
+  });
+
+  describe('groupByParameter', () => {
+    it('should group by parameter value', () => {
+      const groups = groupByParameter(mockMetrics, 'difficulty');
+      expect(groups.size).toBe(2);
+      expect(groups.get(1)!).toHaveLength(2);
+      expect(groups.get(2)!).toHaveLength(2);
+    });
+    it('should handle missing parameter', () => {
+      const groups = groupByParameter(mockMetrics, 'nonexistent');
+      expect(groups.size).toBe(0);
+    });
+  });
+
+  describe('summarizeMetrics', () => {
+    it('should produce correct summary', () => {
+      const summary = summarizeMetrics(mockMetrics, 'score');
+      expect(summary.n).toBe(4);
+      expect(summary.mean).toBeCloseTo(92.5, 1);
+      expect(summary.min).toBe(70);
+      expect(summary.max).toBe(120);
+      expect(summary.std).toBeGreaterThan(0);
+    });
+    it('should handle missing metric', () => {
+      const summary = summarizeMetrics(mockMetrics, 'nonexistent');
+      expect(summary.n).toBe(0);
+    });
+  });
+});
+
+// =============================================================================
+// TRAIT DEFINITIONS
+// =============================================================================
+
+describe('SimulationLab Traits', () => {
+  it('should define @simulation_lab trait', () => {
+    expect(SimulationLabTraits.simulation_lab).toBeDefined();
+    expect(SimulationLabTraits.simulation_lab.name).toBe('@simulation_lab');
+  });
+
+  it('should require hypothesis and metrics params', () => {
+    const trait = SimulationLabTraits.simulation_lab;
+    expect(trait.params!.hypothesis.required).toBe(true);
+    expect(trait.params!.metrics.required).toBe(true);
+  });
+
+  it('should validate correct params', () => {
+    const valid = SimulationLabTraits.simulation_lab.validator!({
+      hypothesis: 'Test hypothesis',
+      metrics: ['score'],
+      epochs: 100,
+      confidence_level: 0.95,
+      direction: 'greater',
+    });
+    expect(valid).toBe(true);
+  });
+
+  it('should reject missing hypothesis', () => {
+    const invalid = SimulationLabTraits.simulation_lab.validator!({
+      metrics: ['score'],
+    });
+    expect(invalid).toBe(false);
+  });
+
+  it('should reject empty metrics', () => {
+    const invalid = SimulationLabTraits.simulation_lab.validator!({
+      hypothesis: 'Test',
+      metrics: [],
+    });
+    expect(invalid).toBe(false);
+  });
+
+  it('should reject invalid direction', () => {
+    const invalid = SimulationLabTraits.simulation_lab.validator!({
+      hypothesis: 'Test',
+      metrics: ['x'],
+      direction: 'sideways',
+    });
+    expect(invalid).toBe(false);
+  });
+
+  it('should compose with all economic traits', () => {
+    const trait = SimulationLabTraits.simulation_lab;
+    expect(trait.composesWith).toContain('@tradeable');
+    expect(trait.composesWith).toContain('@pid_controlled');
+    expect(trait.composesWith).toContain('@bonding_curved');
+  });
+
+  it('should use worker thread for batch execution', () => {
+    const hints = SimulationLabTraits.simulation_lab.compiler_hints;
+    expect(hints?.thread_safety).toBe('worker_thread');
+    expect(hints?.batch_mode).toBe(true);
+  });
+
+  describe('getSimulationTraitNames', () => {
+    it('should return trait names', () => {
+      const names = getSimulationTraitNames();
+      expect(names).toContain('@simulation_lab');
+    });
+  });
+
+  describe('getSimulationTrait', () => {
+    it('should find by name with @', () => {
+      expect(getSimulationTrait('@simulation_lab')).toBeDefined();
+    });
+    it('should find by name without @', () => {
+      expect(getSimulationTrait('simulation_lab')).toBeDefined();
+    });
+    it('should return undefined for unknown', () => {
+      expect(getSimulationTrait('@unknown')).toBeUndefined();
+    });
+  });
+});

package/src/__tests__/collections.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest';
+import { List } from '../collections.js';
+
+describe('List', () => {
+  describe('construction', () => {
+    it('should create empty list', () => {
+      const list = new List<number>();
+      expect(list.length).toBe(0);
+      expect(list.isEmpty).toBe(true);
+    });
+
+    it('should create from array', () => {
+      const list = new List([1, 2, 3]);
+      expect(list.length).toBe(3);
+    });
+
+    it('should create with List.of()', () => {
+      const list = List.of(1, 2, 3);
+      expect(list.length).toBe(3);
+    });
+
+    it('should create with List.from()', () => {
+      const list = List.from([1, 2, 3]);
+      expect(list.length).toBe(3);
+    });
+  });
+
+  describe('List.range()', () => {
+    it('should create range with positive step', () => {
+      const list = List.range(0, 5, 1);
+      expect(list.toArray()).toEqual([0, 1, 2, 3, 4]);
+    });
+
+    it('should create range with default step', () => {
+      const list = List.range(0, 3);
+      expect(list.toArray()).toEqual([0, 1, 2]);
+    });
+
+    it('should create range with custom step', () => {
+      const list = List.range(0, 10, 2);
+      expect(list.toArray()).toEqual([0, 2, 4, 6, 8]);
+    });
+
+    it('should create range with negative step', () => {
+      const list = List.range(5, 0, -1);
+      expect(list.toArray()).toEqual([5, 4, 3, 2, 1]);
+    });
+  });
+
+  describe('List.repeat()', () => {
+    it('should create list with repeated values', () => {
+      const list = List.repeat('a', 3);
+      expect(list.toArray()).toEqual(['a', 'a', 'a']);
+    });
+
+    it('should create empty list with count 0', () => {
+      const list = List.repeat('a', 0);
+      expect(list.isEmpty).toBe(true);
+    });
+  });
+
+  describe('accessors', () => {
+    const list = List.of(10, 20, 30, 40, 50);
+
+    it('should get element by positive index', () => {
+      expect(list.get(0)).toBe(10);
+      expect(list.get(2)).toBe(30);
+    });
+
+    it('should get element by negative index', () => {
+      expect(list.get(-1)).toBe(50);
+      expect(list.get(-2)).toBe(40);
+    });
+
+    it('should return undefined for out of bounds', () => {
+      expect(list.get(10)).toBeUndefined();
+    });
+
+    it('should get first element', () => {
+      expect(list.first()).toBe(10);
+    });
+
+    it('should get last element', () => {
+      expect(list.last()).toBe(50);
+    });
+
+    it('should return undefined for first/last on empty list', () => {
+      const empty = new List<number>();
+      expect(empty.first()).toBeUndefined();
+      expect(empty.last()).toBeUndefined();
+    });
+  });
+
+  describe('map', () => {
+    it('should map over elements', () => {
+      const list = List.of(1, 2, 3);
+      const doubled = list.map((x) => x * 2);
+      expect(doubled.toArray()).toEqual([2, 4, 6]);
+    });
+
+    it('should receive index in map callback', () => {
+      const list = List.of('a', 'b', 'c');
+      const indexed = list.map((_, i) => i);
+      expect(indexed.toArray()).toEqual([0, 1, 2]);
+    });
+
+    it('should return new List instance', () => {
+      const list = List.of(1, 2, 3);
+      const mapped = list.map((x) => x);
+      expect(mapped).not.toBe(list);
+    });
+  });
+
+  describe('filter', () => {
+    it('should filter elements', () => {
+      const list = List.of(1, 2, 3, 4, 5);
+      const evens = list.filter((x) => x % 2 === 0);
+      expect(evens.toArray()).toEqual([2, 4]);
+    });
+
+    it('should return empty list when nothing matches', () => {
+      const list = List.of(1, 3, 5);
+      const evens = list.filter((x) => x % 2 === 0);
+      expect(evens.isEmpty).toBe(true);
+    });
+  });
+
+  describe('flatMap', () => {
+    it('should flatMap with arrays', () => {
+      const list = List.of(1, 2, 3);
+      const result = list.flatMap((x) => [x, x * 10]);
+      expect(result.toArray()).toEqual([1, 10, 2, 20, 3, 30]);
+    });
+
+    it('should flatMap with Lists', () => {
+      const list = List.of(1, 2);
+      const result = list.flatMap((x) => List.of(x, x + 1));
+      expect(result.toArray()).toEqual([1, 2, 2, 3]);
+    });
+  });
+
+  describe('reduce', () => {
+    it('should reduce with initial value', () => {
+      const list = List.of(1, 2, 3, 4);
+      const sum = list.reduce((acc, x) => acc + x, 0);
+      expect(sum).toBe(10);
+    });
+  });
+
+  describe('immutability', () => {
+    it('operations should return new List instances', () => {
+      const original = List.of(1, 2, 3);
+      const mapped = original.map((x) => x * 2);
+      const filtered = original.filter((x) => x > 1);
+
+      expect(original.toArray()).toEqual([1, 2, 3]);
+      expect(mapped.toArray()).toEqual([2, 4, 6]);
+      expect(filtered.toArray()).toEqual([2, 3]);
+    });
+  });
+
+  describe('toArray', () => {
+    it('should return array copy', () => {
+      const list = List.of(1, 2, 3);
+      const arr = list.toArray();
+      expect(arr).toEqual([1, 2, 3]);
+      arr.push(4);
+      expect(list.length).toBe(3); // Original unchanged
+    });
+  });
+
+  describe('iteration', () => {
+    it('should be iterable', () => {
+      const list = List.of(1, 2, 3);
+      const result: number[] = [];
+      for (const item of list) {
+        result.push(item);
+      }
+      expect(result).toEqual([1, 2, 3]);
+    });
+  });
+});