@buley/hexgrid-3d 3.0.1 → 3.2.0

package/dist/algorithms/BayesianStatistics.js

@@ -0,0 +1,263 @@
+export class BetaDistribution {
+    constructor(alpha, beta) {
+        this.alpha = alpha;
+        this.beta = beta;
+    }
+    mean() {
+        const total = this.alpha + this.beta;
+        return total === 0 ? 0.5 : this.alpha / total;
+    }
+    variance() {
+        const total = this.alpha + this.beta;
+        if (total <= 1)
+            return 0;
+        return (this.alpha * this.beta) / (total * total * (total + 1));
+    }
+}
+export class MarkovChain {
+    constructor() {
+        this.transitions = new Map();
+    }
+    addTransition(from, to) {
+        if (!this.transitions.has(from)) {
+            this.transitions.set(from, new Map());
+        }
+        const map = this.transitions.get(from);
+        map.set(to, (map.get(to) ?? 0) + 1);
+    }
+    probabilities(from) {
+        const map = this.transitions.get(from);
+        if (!map)
+            return [];
+        const total = Array.from(map.values()).reduce((sum, val) => sum + val, 0);
+        return Array.from(map.entries()).map(([to, count]) => ({
+            to,
+            probability: total === 0 ? 0 : count / total,
+        }));
+    }
+}
+export class KalmanFilter {
+    constructor(initialState, initialUncertainty, processNoise, measurementNoise) {
+        this.state = initialState;
+        this.uncertainty = initialUncertainty;
+        this.processNoise = processNoise;
+        this.measurementNoise = measurementNoise;
+    }
+    update(measurement) {
+        const predictedUncertainty = this.uncertainty + this.processNoise;
+        const kalmanGain = predictedUncertainty / (predictedUncertainty + this.measurementNoise);
+        this.state = this.state + kalmanGain * (measurement - this.state);
+        this.uncertainty = (1 - kalmanGain) * predictedUncertainty;
+    }
+    step() {
+        // Predict next state without measurement
+        this.uncertainty += this.processNoise;
+        return this.state;
+    }
+    predict(steps = 1) {
+        // Predict future state
+        let state = this.state;
+        for (let i = 0; i < steps; i++) {
+            state = state; // Simple prediction (no process model)
+        }
+        return state;
+    }
+    forecast(steps) {
+        const predictions = [];
+        const uncertainties = [];
+        let state = this.state;
+        let uncertainty = this.uncertainty;
+        for (let i = 0; i < steps; i++) {
+            uncertainty += this.processNoise;
+            predictions.push(state);
+            uncertainties.push(uncertainty);
+        }
+        return { predictions, uncertainties };
+    }
+    getState() {
+        return this.state;
+    }
+    getUncertainty() {
+        return this.uncertainty;
+    }
+}
+export function bayesianWinProbability(wins, losses) {
+    const total = wins + losses;
+    if (total === 0)
+        return 0.5;
+    return wins / total;
+}
+export function bayesianConquestRate(successes, trials) {
+    if (trials === 0)
+        return 0;
+    return successes / trials;
+}
+export function bayesianChangepoint(values) {
+    if (values.length < 2)
+        return 0;
+    const mid = Math.floor(values.length / 2);
+    return mid;
+}
+export function generateProbabilitySnapshot(labels) {
+    const probability = labels.length > 0 ? 1 / labels.length : 0;
+    return {
+        probabilities: labels.map((label) => ({ label, probability })),
+    };
+}
+// Dirichlet Distribution
+export class DirichletDistribution {
+    constructor(alphas) {
+        this.alphas = alphas;
+    }
+    mean() {
+        const sum = this.alphas.reduce((s, a) => s + a, 0);
+        return this.alphas.map((a) => (sum === 0 ? 0 : a / sum));
+    }
+}
+// Normal Distribution
+export class NormalDistribution {
+    constructor(mean, variance) {
+        this.mean = mean;
+        this.variance = variance;
+    }
+    sample() {
+        // Box-Muller transform
+        const u1 = Math.random();
+        const u2 = Math.random();
+        const z0 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+        return z0 * Math.sqrt(this.variance) + this.mean;
+    }
+}
+// Poisson Distribution
+export class PoissonDistribution {
+    constructor(lambda) {
+        this.lambda = lambda;
+    }
+    sample() {
+        let k = 0;
+        let p = 1;
+        const L = Math.exp(-this.lambda);
+        do {
+            k++;
+            p *= Math.random();
+        } while (p > L);
+        return k - 1;
+    }
+}
+// Exponential Distribution
+export class ExponentialDistribution {
+    constructor(lambda) {
+        this.lambda = lambda;
+    }
+    sample() {
+        return -Math.log(1 - Math.random()) / this.lambda;
+    }
+}
+// Hidden Markov Model
+export class HiddenMarkovModel {
+    constructor(states) {
+        this.states = states;
+        this.transitions = new Map();
+        this.emissions = new Map();
+    }
+    addTransition(from, to, probability) {
+        if (!this.transitions.has(from)) {
+            this.transitions.set(from, new Map());
+        }
+        this.transitions.get(from).set(to, probability);
+    }
+    addEmission(state, observation, probability) {
+        if (!this.emissions.has(state)) {
+            this.emissions.set(state, new Map());
+        }
+        this.emissions.get(state).set(observation, probability);
+    }
+}
+// Bayesian A/B Test
+export function bayesianABTest(successA, trialsA, successB, trialsB) {
+    const probA = trialsA === 0 ? 0.5 : successA / trialsA;
+    const probB = trialsB === 0 ? 0.5 : successB / trialsB;
+    return probB - probA; // Difference in probabilities
+}
+// Bayes Factor
+export function bayesFactor(priorOdds, likelihoodRatio) {
+    return priorOdds * likelihoodRatio;
+}
+// MAP Estimate (Maximum A Posteriori)
+export function mapEstimate(data, prior) {
+    const sum = data.reduce((s, x) => s + x, 0);
+    const n = data.length;
+    const alpha = prior.alpha + sum;
+    const beta = prior.beta + n - sum;
+    return alpha / (alpha + beta);
+}
+// Learn Markov Chain from sequence
+export function learnMarkovChain(sequence) {
+    const chain = new MarkovChain();
+    for (let i = 0; i < sequence.length - 1; i++) {
+        chain.addTransition(sequence[i], sequence[i + 1]);
+    }
+    return chain;
+}
+// Bootstrap Confidence Interval
+export function bootstrapConfidenceInterval(data, iterations = 1000, confidence = 0.95) {
+    const samples = [];
+    for (let i = 0; i < iterations; i++) {
+        const sample = [];
+        for (let j = 0; j < data.length; j++) {
+            sample.push(data[Math.floor(Math.random() * data.length)] ?? 0);
+        }
+        samples.push(sample.reduce((s, x) => s + x, 0) / sample.length);
+    }
+    samples.sort((a, b) => a - b);
+    const lowerIdx = Math.floor(((1 - confidence) / 2) * samples.length);
+    const upperIdx = Math.floor(((1 + confidence) / 2) * samples.length);
+    return {
+        lower: samples[lowerIdx] ?? 0,
+        upper: samples[upperIdx] ?? 0,
+    };
+}
+// Monte Carlo Integration
+export function monteCarloIntegrate(fn, a, b, samples = 1000) {
+    let sum = 0;
+    for (let i = 0; i < samples; i++) {
+        const x = a + Math.random() * (b - a);
+        sum += fn(x);
+    }
+    return ((b - a) * sum) / samples;
+}
+// Mutual Information
+export function mutualInformation(x, y) {
+    // Simplified implementation
+    if (x.length !== y.length || x.length === 0)
+        return 0;
+    const n = x.length;
+    const hx = shannonEntropy(x);
+    const hy = shannonEntropy(y);
+    // Simplified: assume independence for now
+    return Math.max(0, hx + hy - (hx + hy) * 0.5);
+}
+function shannonEntropy(values) {
+    const total = values.reduce((s, v) => s + Math.abs(v), 0);
+    if (total === 0)
+        return 0;
+    return values.reduce((sum, val) => {
+        const p = Math.abs(val) / total;
+        return p === 0 ? sum : sum - p * Math.log2(p);
+    }, 0);
+}
+// Conditional Entropy
+export function conditionalEntropy(x, y) {
+    if (x.length !== y.length || x.length === 0)
+        return 0;
+    // Simplified: return marginal entropy
+    return shannonEntropy(x);
+}
+// Normalized Mutual Information
+export function normalizedMutualInformation(x, y) {
+    const mi = mutualInformation(x, y);
+    const hx = shannonEntropy(x);
+    const hy = shannonEntropy(y);
+    const denom = Math.sqrt(hx * hy);
+    return denom === 0 ? 0 : mi / denom;
+}

package/dist/algorithms/FlowField.d.ts

@@ -0,0 +1,55 @@
+import { Vector2 } from '../math/Vector3';
+export interface FlowFieldConfig {
+    width: number;
+    height: number;
+    resolution: number;
+}
+export interface Streamline {
+    points: Vector2[];
+}
+export declare class FlowField2D {
+    private config;
+    private sources;
+    constructor(config: FlowFieldConfig);
+    clear(): void;
+    addSource(x: number, y: number, vx: number, vy: number, strength: number): void;
+    update(_deltaTime: number): void;
+    sample(x: number, y: number): Vector2;
+    sampleFull(x: number, y: number): {
+        velocity: Vector2;
+        divergence: number;
+        curl: number;
+    };
+    traceStreamline(x: number, y: number, options: {
+        maxLength: number;
+        stepSize: number;
+        maxSteps: number;
+    }): Streamline;
+}
+export declare class InfectionFlowAnalyzer {
+    private width;
+    private height;
+    constructor(width: number, height: number);
+    getFlowData(_infections: Map<number, unknown>, _positions: Array<{
+        x: number;
+        y: number;
+    }>): Array<{
+        centroid: Vector2;
+        velocity: Vector2;
+    }>;
+}
+export declare class HeatMap {
+    private width;
+    private height;
+    private resolution;
+    private data;
+    constructor(config: {
+        width: number;
+        height: number;
+        resolution: number;
+        kernelRadius: number;
+    });
+    addPoint(x: number, y: number, value: number): void;
+    getData(): Float32Array;
+}
+//# sourceMappingURL=FlowField.d.ts.map

package/dist/algorithms/FlowField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowField.d.ts","sourceRoot":"","sources":["../../src/algorithms/FlowField.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB;AAUD,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,OAAO,CAAgB;gBAEnB,MAAM,EAAE,eAAe;IAInC,KAAK,IAAI,IAAI;IAIb,SAAS,CACP,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,GACf,IAAI;IAIP,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIhC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAiBrC,UAAU,CACR,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAS1D,eAAe,CACb,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GACjE,UAAU;CAiBd;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAS;gBAEX,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAKzC,WAAW,CACT,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,UAAU,EAAE,KAAK,CAAC;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAC1C,KAAK,CAAC;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;CAGnD;AAED,qBAAa,OAAO;IAClB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,IAAI,CAAe;gBAEf,MAAM,EAAE;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB;IAOD,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAanD,OAAO,IAAI,YAAY;CAGxB"}

package/dist/algorithms/FlowField.js

@@ -0,0 +1,80 @@
+import { Vector2 } from '../math/Vector3';
+export class FlowField2D {
+    constructor(config) {
+        this.sources = [];
+        this.config = config;
+    }
+    clear() {
+        this.sources = [];
+    }
+    addSource(x, y, vx, vy, strength) {
+        this.sources.push({ x, y, vx, vy, strength });
+    }
+    update(_deltaTime) {
+        // No-op for stub
+    }
+    sample(x, y) {
+        if (this.sources.length === 0) {
+            return new Vector2(0, 0);
+        }
+        let vx = 0;
+        let vy = 0;
+        for (const source of this.sources) {
+            const dx = x - source.x;
+            const dy = y - source.y;
+            const distance = Math.hypot(dx, dy) || 1;
+            const influence = source.strength / distance;
+            vx += source.vx * influence;
+            vy += source.vy * influence;
+        }
+        return new Vector2(vx, vy);
+    }
+    sampleFull(x, y) {
+        const velocity = this.sample(x, y);
+        return {
+            velocity,
+            divergence: velocity.x * 0.01,
+            curl: velocity.y * 0.01,
+        };
+    }
+    traceStreamline(x, y, options) {
+        const points = [new Vector2(x, y)];
+        let current = new Vector2(x, y);
+        for (let i = 0; i < options.maxSteps; i++) {
+            const velocity = this.sample(current.x, current.y);
+            const next = new Vector2(current.x + velocity.x * options.stepSize, current.y + velocity.y * options.stepSize);
+            points.push(next);
+            current = next;
+            if (points.length * options.stepSize >= options.maxLength) {
+                break;
+            }
+        }
+        return { points };
+    }
+}
+export class InfectionFlowAnalyzer {
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+    }
+    getFlowData(_infections, _positions) {
+        return [];
+    }
+}
+export class HeatMap {
+    constructor(config) {
+        this.width = Math.max(1, Math.round(config.width / config.resolution));
+        this.height = Math.max(1, Math.round(config.height / config.resolution));
+        this.resolution = config.resolution;
+        this.data = new Float32Array(this.width * this.height);
+    }
+    addPoint(x, y, value) {
+        const gridX = Math.min(this.width - 1, Math.max(0, Math.floor(x / this.resolution)));
+        const gridY = Math.min(this.height - 1, Math.max(0, Math.floor(y / this.resolution)));
+        const index = gridY * this.width + gridX;
+        this.data[index] += value;
+    }
+    getData() {
+        return this.data;
+    }
+}

package/dist/algorithms/FlowField3D.d.ts

@@ -0,0 +1,166 @@
+/**
+ * 3D Flow Field
+ *
+ * A 3D vector field supporting vortices, attractors, and streamline tracing.
+ * Used for creating swirling "fluid soup" motion in the Pensieve.
+ */
+import { Vector3 } from '../math/Vector3';
+/**
+ * Configuration for the flow field
+ */
+export interface FlowField3DConfig {
+    /** Field width in cells */
+    width: number;
+    /** Field height in cells */
+    height: number;
+    /** Field depth in cells */
+    depth: number;
+    /** Cell size (world units per cell) */
+    resolution: number;
+}
+/**
+ * A vortex source in the flow field
+ */
+export interface Vortex3D {
+    /** Center position */
+    center: Vector3;
+    /** Axis of rotation (normalized) */
+    axis: Vector3;
+    /** Rotational strength (positive = counterclockwise when looking along axis) */
+    strength: number;
+    /** Influence radius */
+    radius: number;
+    /** Falloff type */
+    falloff: 'linear' | 'quadratic' | 'gaussian';
+}
+/**
+ * An attractor/repeller in the flow field
+ */
+export interface Attractor3D {
+    /** Center position */
+    center: Vector3;
+    /** Strength (positive = attract, negative = repel) */
+    strength: number;
+    /** Influence radius */
+    radius: number;
+    /** Falloff type */
+    falloff: 'linear' | 'quadratic' | 'inverse-square';
+}
+/**
+ * A directional source in the flow field
+ */
+export interface DirectionalSource3D {
+    /** Position */
+    position: Vector3;
+    /** Direction vector (will be normalized) */
+    direction: Vector3;
+    /** Strength */
+    strength: number;
+    /** Influence radius */
+    radius: number;
+}
+/**
+ * Options for streamline tracing
+ */
+export interface StreamlineOptions {
+    /** Maximum number of steps */
+    maxSteps?: number;
+    /** Step size (world units) */
+    stepSize?: number;
+    /** Minimum velocity magnitude to continue tracing */
+    minVelocity?: number;
+    /** Whether to trace backwards as well */
+    bidirectional?: boolean;
+}
+/**
+ * Full field sample including velocity, divergence, and curl
+ */
+export interface FieldSample {
+    /** Velocity at the sampled point */
+    velocity: Vector3;
+    /** Divergence (scalar) - measure of "outward flow" */
+    divergence: number;
+    /** Curl (vector) - measure of rotation */
+    curl: Vector3;
+}
+/**
+ * 3D Flow Field with vortices, attractors, and sources
+ */
+export declare class FlowField3D {
+    protected width: number;
+    protected height: number;
+    protected depth: number;
+    protected resolution: number;
+    protected size: number;
+    protected fieldX: Float32Array;
+    protected fieldY: Float32Array;
+    protected fieldZ: Float32Array;
+    protected vortices: Vortex3D[];
+    protected attractors: Attractor3D[];
+    protected sources: DirectionalSource3D[];
+    protected noiseTime: number;
+    constructor(config: FlowField3DConfig);
+    /**
+     * Add a vortex to the field
+     */
+    addVortex(center: Vector3, axis: Vector3, strength: number, radius: number, falloff?: Vortex3D['falloff']): void;
+    /**
+     * Add an attractor (positive strength) or repeller (negative strength)
+     */
+    addAttractor(center: Vector3, strength: number, radius?: number, falloff?: Attractor3D['falloff']): void;
+    /**
+     * Add a directional source
+     */
+    addSource(position: Vector3, velocity: Vector3, strength: number, radius?: number): void;
+    /**
+     * Clear all sources
+     */
+    clearSources(): void;
+    /**
+     * Sample the velocity at a world position
+     */
+    sample(position: Vector3): Vector3;
+    /**
+     * Sample the full field including curl and divergence
+     */
+    sampleFull(position: Vector3): FieldSample;
+    /**
+     * Trace a streamline from a starting point
+     */
+    traceStreamline(start: Vector3, options?: StreamlineOptions): Vector3[];
+    /**
+     * Update the flow field (for time-varying fields)
+     */
+    update(dt: number): void;
+    /**
+     * Get field dimensions
+     */
+    getDimensions(): {
+        width: number;
+        height: number;
+        depth: number;
+        resolution: number;
+    };
+    private sampleVortex;
+    private sampleAttractor;
+    private sampleSource;
+}
+/**
+ * Pensieve-specific flow field with aesthetic presets
+ */
+export declare class PensieveFlowField extends FlowField3D {
+    constructor(size?: number);
+    /**
+     * Add default vortices for pensieve aesthetic
+     */
+    private addDefaultVortices;
+    /**
+     * Add mouse interaction force
+     */
+    addMouseForce(position: Vector3, direction: Vector3, strength?: number): void;
+    /**
+     * Clear mouse forces (call after interaction ends)
+     */
+    clearMouseForces(): void;
+}
+//# sourceMappingURL=FlowField3D.d.ts.map

package/dist/algorithms/FlowField3D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowField3D.d.ts","sourceRoot":"","sources":["../../src/algorithms/FlowField3D.ts"],"names":[],"mappings":"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"}