@buley/hexgrid-3d 3.1.0 → 3.2.1

package/dist/adapters/DashAdapter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Adapter for Zero-Copy Data Sync between Dash 2.0 and HexGrid-3D.
+ *
+ * This adapter subscribes to a Dash "LiveQuery" which returns pointers to shared memory (SharedArrayBuffer)
+ * or Float32Arrays. It then syncs this data directly to the HexGridWasm instance.
+ */
+export declare class DashAdapter {
+    private dash;
+    constructor(dashInstance: any);
+    /**
+     * Subscribe to a semantic query in Dash and sync results to HexGrid.
+     *
+     * @param query The vector search query
+     * @param gridInstance The WASM instance of the HexGrid
+     */
+    bindSemanticSearch(query: string, particleSystem: any): void;
+}
+//# sourceMappingURL=DashAdapter.d.ts.map

package/dist/adapters/DashAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/DashAdapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAM;gBAEN,YAAY,EAAE,GAAG;IAI7B;;;;;OAKG;IACH,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG;CA6BtD"}

package/dist/adapters/DashAdapter.js

@@ -0,0 +1,42 @@
+/**
+ * Adapter for Zero-Copy Data Sync between Dash 2.0 and HexGrid-3D.
+ *
+ * This adapter subscribes to a Dash "LiveQuery" which returns pointers to shared memory (SharedArrayBuffer)
+ * or Float32Arrays. It then syncs this data directly to the HexGridWasm instance.
+ */
+export class DashAdapter {
+    constructor(dashInstance) {
+        this.dash = dashInstance;
+    }
+    /**
+     * Subscribe to a semantic query in Dash and sync results to HexGrid.
+     *
+     * @param query The vector search query
+     * @param gridInstance The WASM instance of the HexGrid
+     */
+    bindSemanticSearch(query, particleSystem) {
+        console.log('[DashAdapter] Binding semantic search:', query);
+        // Hypothetical Zero-Copy API from Dash 2.0
+        if (this.dash.liveQueryPtr) {
+            this.dash.liveQueryPtr(`SELECT embedding FROM dash_vec_idx WHERE embedding MATCH '${query}'`).subscribe((handle) => {
+                console.log(`[DashAdapter] Received ${handle.size} bytes from Dash.`);
+                // Assume the handle.buffer contains [pos, color, scale] interleaved or tightly packed
+                // For this MVP, we treat it as just positions
+                const floatView = new Float32Array(handle.buffer);
+                // Zero-Copy Injection logic would go here
+                // We can't strictly "inject" one buffer into 3 separate Float32Arrays unless they are contiguous in the SAB
+                // or we create views into offsets.
+                // Hypothetical offset logic:
+                const count = handle.size / 4 / 7; // pos + color + scale = 3+3+1 = 7 floats
+                // particleSystem.setSharedBuffers({
+                //     positions: floatView.subarray(0, count * 3),
+                //     colors: floatView.subarray(count * 3, count * 6),
+                //     scales: floatView.subarray(count * 6, count * 7)
+                // });
+            });
+        }
+        else {
+            console.warn('[DashAdapter] Dash instance does not support Zero-Copy liveQueryPtr yet.');
+        }
+    }
+}

package/dist/adapters.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Type-safe adapter pattern for converting domain objects to GridItems
+ */
+import type { GridItem } from './types';
+/**
+ * Options for adapter conversion
+ */
+export interface AdapterOptions {
+    /**
+     * Custom velocity calculation override
+     */
+    velocity?: number;
+    /**
+     * Custom visual URL override
+     */
+    visualUrl?: string;
+    /**
+     * Additional metadata to merge
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Type-safe adapter for converting domain objects to GridItems
+ */
+export interface ItemAdapter<T> {
+    /**
+     * Convert a domain object to a GridItem
+     */
+    toGridItem(data: T, options?: AdapterOptions): GridItem<T>;
+    /**
+     * Extract the original domain object from a GridItem
+     */
+    fromGridItem(item: GridItem<T>): T;
+    /**
+     * Calculate velocity for the item (optional)
+     */
+    calculateVelocity?(data: T): number;
+    /**
+     * Extract visual URL for the item (optional)
+     */
+    extractVisualUrl?(data: T): string | undefined;
+}
+/**
+ * Helper to create adapters for common patterns
+ */
+export declare function createAdapter<T>(config: {
+    type: string;
+    toGridItem: (data: T, options?: AdapterOptions) => GridItem<T>;
+    fromGridItem: (item: GridItem<T>) => T;
+    calculateVelocity?: (data: T) => number;
+    extractVisualUrl?: (data: T) => string | undefined;
+}): ItemAdapter<T>;
+//# sourceMappingURL=adapters.d.ts.map

package/dist/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../src/adapters.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC3D;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACnC;;OAEG;IACH,iBAAiB,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC;IACpC;;OAEG;IACH,gBAAgB,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS,CAAC;CAChD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC/D,YAAY,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IACvC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;IACxC,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,CAAC;CACpD,GAAG,WAAW,CAAC,CAAC,CAAC,CAOjB"}

package/dist/adapters.js

@@ -0,0 +1,14 @@
+/**
+ * Type-safe adapter pattern for converting domain objects to GridItems
+ */
+/**
+ * Helper to create adapters for common patterns
+ */
+export function createAdapter(config) {
+    return {
+        toGridItem: config.toGridItem,
+        fromGridItem: config.fromGridItem,
+        calculateVelocity: config.calculateVelocity,
+        extractVisualUrl: config.extractVisualUrl,
+    };
+}

package/dist/algorithms/AdvancedStatistics.d.ts

@@ -0,0 +1,52 @@
+export interface TrendResult {
+    slope: number;
+    direction: 'increasing' | 'decreasing' | 'stable';
+    rSquared?: number;
+}
+export declare function giniCoefficient(values: number[]): number;
+export declare function theilIndex(values: number[]): number;
+export declare function atkinsonIndex(values: number[], epsilon: number): number;
+export declare function paretoRatio(values: number[], topFraction: number): {
+    ratioHeld: number;
+    paretoIndex: number;
+};
+export declare function zipfCoefficient(values: number[]): number;
+export declare function herfindahlIndex(values: number[]): number;
+export declare function shannonEntropy(values: number[]): number;
+export declare function normalizedEntropy(values: number[]): number;
+export declare function renyiEntropy(values: number[], alpha: number): number;
+export declare function tsallisEntropy(values: number[], q: number): number;
+export declare function detectTrend(values: number[]): TrendResult;
+export declare function detectChangePoints(values: number[]): number[];
+export declare function movingAverage(values: number[], windowSize: number): number[];
+export declare function exponentialMovingAverage(values: number[], alpha: number): number[];
+export declare function predictWinner(values: number[]): number;
+export declare function sparkline(values: number[]): string;
+export declare function sparklineSvg(values: number[], width?: number, height?: number): string;
+export declare function klDivergence(p: number[], q: number[]): number;
+export declare function jsDivergence(p: number[], q: number[]): number;
+export declare function bhattacharyyaCoefficient(p: number[], q: number[]): number;
+export declare function hellingerDistance(p: number[], q: number[]): number;
+export declare function doubleExponentialSmoothing(values: number[], alpha?: number, beta?: number): number[];
+export declare function eulerCharacteristic(vertices: number, edges: number, faces: number): number;
+export declare function estimateBettiNumbers(complex: {
+    vertices: number;
+    edges: number;
+    faces: number;
+}): {
+    b0: number;
+    b1: number;
+};
+export declare function compactness(area: number, perimeter: number): number;
+export interface TerritoryStats {
+    totalTerritories: number;
+    averageSize: number;
+    largestTerritory: number;
+    smallestTerritory: number;
+    compactness: number;
+}
+export declare function computeTerritoryStats(territories: Array<{
+    area: number;
+    perimeter: number;
+}>): TerritoryStats;
+//# sourceMappingURL=AdvancedStatistics.d.ts.map

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

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

package/dist/algorithms/AdvancedStatistics.js

@@ -0,0 +1,307 @@
+export function giniCoefficient(values) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const total = sorted.reduce((sum, val) => sum + val, 0);
+    if (total === 0)
+        return 0;
+    const n = sorted.length;
+    let cumulative = 0;
+    for (let i = 0; i < n; i++) {
+        cumulative += (i + 1) * sorted[i];
+    }
+    return (2 * cumulative) / (n * total) - (n + 1) / n;
+}
+export function theilIndex(values) {
+    if (values.length === 0)
+        return 0;
+    const avg = values.reduce((sum, val) => sum + val, 0) / values.length;
+    if (avg === 0)
+        return 0;
+    return (values.reduce((sum, val) => {
+        const ratio = val / avg;
+        return sum + (ratio === 0 ? 0 : ratio * Math.log(ratio));
+    }, 0) / values.length);
+}
+export function atkinsonIndex(values, epsilon) {
+    if (values.length === 0)
+        return 0;
+    const avg = values.reduce((sum, val) => sum + val, 0) / values.length;
+    if (avg === 0)
+        return 0;
+    if (epsilon === 1) {
+        const geomMean = Math.exp(values.reduce((sum, val) => sum + Math.log(Math.max(val, 1e-9)), 0) /
+            values.length);
+        return 1 - geomMean / avg;
+    }
+    const meanPower = values.reduce((sum, val) => sum + Math.pow(val, 1 - epsilon), 0) /
+        values.length;
+    const eq = Math.pow(meanPower, 1 / (1 - epsilon));
+    return 1 - eq / avg;
+}
+export function paretoRatio(values, topFraction) {
+    if (values.length === 0)
+        return { ratioHeld: 0, paretoIndex: 0 };
+    const sorted = [...values].sort((a, b) => b - a);
+    const total = sorted.reduce((sum, val) => sum + val, 0);
+    if (total === 0)
+        return { ratioHeld: 0, paretoIndex: 0 };
+    const topCount = Math.max(1, Math.floor(values.length * topFraction));
+    const topSum = sorted.slice(0, topCount).reduce((sum, val) => sum + val, 0);
+    return { ratioHeld: topSum / total, paretoIndex: topFraction };
+}
+export function zipfCoefficient(values) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => b - a);
+    const total = sorted.reduce((sum, val) => sum + val, 0);
+    if (total === 0)
+        return 0;
+    return sorted.reduce((sum, val, idx) => sum + val / (idx + 1), 0) / total;
+}
+export function herfindahlIndex(values) {
+    if (values.length === 0)
+        return 0;
+    const total = values.reduce((sum, val) => sum + val, 0);
+    if (total === 0)
+        return 0;
+    return values.reduce((sum, val) => {
+        const share = val / total;
+        return sum + share * share;
+    }, 0);
+}
+export function shannonEntropy(values) {
+    if (values.length === 0)
+        return 0;
+    const total = values.reduce((sum, val) => sum + val, 0);
+    if (total === 0)
+        return 0;
+    return values.reduce((sum, val) => {
+        const p = val / total;
+        return p === 0 ? sum : sum - p * Math.log2(p);
+    }, 0);
+}
+export function normalizedEntropy(values) {
+    if (values.length === 0)
+        return 0;
+    const entropy = shannonEntropy(values);
+    const maxEntropy = Math.log2(values.length || 1);
+    return maxEntropy === 0 ? 0 : entropy / maxEntropy;
+}
+export function renyiEntropy(values, alpha) {
+    if (values.length === 0)
+        return 0;
+    const total = values.reduce((sum, val) => sum + val, 0);
+    if (total === 0)
+        return 0;
+    const sum = values.reduce((acc, val) => {
+        const p = val / total;
+        return acc + Math.pow(p, alpha);
+    }, 0);
+    return (1 / (1 - alpha)) * Math.log2(sum || 1);
+}
+export function tsallisEntropy(values, q) {
+    if (values.length === 0)
+        return 0;
+    const total = values.reduce((sum, val) => sum + val, 0);
+    if (total === 0)
+        return 0;
+    const sum = values.reduce((acc, val) => {
+        const p = val / total;
+        return acc + Math.pow(p, q);
+    }, 0);
+    return (1 - sum) / (q - 1);
+}
+export function detectTrend(values) {
+    if (values.length < 2) {
+        return { slope: 0, direction: 'stable', rSquared: 0 };
+    }
+    const n = values.length;
+    const xMean = (n - 1) / 2;
+    const yMean = values.reduce((sum, v) => sum + v, 0) / n;
+    let num = 0;
+    let den = 0;
+    let ssRes = 0;
+    let ssTot = 0;
+    for (let i = 0; i < n; i++) {
+        const dx = i - xMean;
+        num += dx * (values[i] - yMean);
+        den += dx * dx;
+    }
+    const slope = den === 0 ? 0 : num / den;
+    const intercept = yMean - slope * xMean;
+    // Calculate R-squared
+    for (let i = 0; i < n; i++) {
+        const predicted = slope * i + intercept;
+        ssRes += Math.pow(values[i] - predicted, 2);
+        ssTot += Math.pow(values[i] - yMean, 2);
+    }
+    const rSquared = ssTot === 0 ? 0 : 1 - ssRes / ssTot;
+    const direction = slope > 0.1 ? 'increasing' : slope < -0.1 ? 'decreasing' : 'stable';
+    return { slope, direction, rSquared };
+}
+export function detectChangePoints(values) {
+    if (values.length < 3)
+        return [];
+    const changes = [];
+    const avg = values.reduce((sum, val) => sum + val, 0) / values.length;
+    const variance = values.reduce((sum, val) => sum + (val - avg) ** 2, 0) / values.length;
+    const threshold = Math.sqrt(variance) * 1.5;
+    for (let i = 1; i < values.length; i++) {
+        if (Math.abs(values[i] - values[i - 1]) > threshold) {
+            changes.push(i);
+        }
+    }
+    return changes;
+}
+export function movingAverage(values, windowSize) {
+    if (values.length === 0)
+        return [];
+    const result = [];
+    for (let i = 0; i < values.length; i++) {
+        const start = Math.max(0, i - windowSize + 1);
+        const window = values.slice(start, i + 1);
+        const avg = window.reduce((sum, val) => sum + val, 0) / window.length;
+        result.push(avg);
+    }
+    return result;
+}
+export function exponentialMovingAverage(values, alpha) {
+    if (values.length === 0)
+        return [];
+    const result = [];
+    let current = values[0] ?? 0;
+    result.push(current);
+    for (let i = 1; i < values.length; i++) {
+        current = alpha * values[i] + (1 - alpha) * current;
+        result.push(current);
+    }
+    return result;
+}
+export function predictWinner(values) {
+    if (values.length === 0)
+        return 0;
+    const max = Math.max(...values);
+    return values.indexOf(max);
+}
+export function sparkline(values) {
+    if (values.length === 0)
+        return '';
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const range = max - min || 1;
+    const ticks = '▁▂▃▄▅▆▇█';
+    return values
+        .map((value) => {
+        const idx = Math.round(((value - min) / range) * (ticks.length - 1));
+        return ticks[idx] ?? ticks[0];
+    })
+        .join('');
+}
+export function sparklineSvg(values, width = 100, height = 20) {
+    if (values.length === 0)
+        return '';
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const range = max - min || 1;
+    const step = width / Math.max(1, values.length - 1);
+    return values
+        .map((value, index) => {
+        const x = index * step;
+        const y = height - ((value - min) / range) * height;
+        return `${index === 0 ? 'M' : 'L'}${x},${y}`;
+    })
+        .join(' ');
+}
+// KL Divergence (Kullback-Leibler)
+export function klDivergence(p, q) {
+    if (p.length !== q.length || p.length === 0)
+        return 0;
+    return p.reduce((sum, pi, i) => {
+        if (pi === 0)
+            return sum;
+        const qi = q[i] ?? 1e-10;
+        return sum + pi * Math.log2(pi / qi);
+    }, 0);
+}
+// JS Divergence (Jensen-Shannon)
+export function jsDivergence(p, q) {
+    if (p.length !== q.length || p.length === 0)
+        return 0;
+    const m = p.map((pi, i) => (pi + (q[i] ?? 0)) / 2);
+    return (klDivergence(p, m) + klDivergence(q, m)) / 2;
+}
+// Bhattacharyya Coefficient
+export function bhattacharyyaCoefficient(p, q) {
+    if (p.length !== q.length || p.length === 0)
+        return 0;
+    return p.reduce((sum, pi, i) => {
+        const qi = q[i] ?? 0;
+        return sum + Math.sqrt(pi * qi);
+    }, 0);
+}
+// Hellinger Distance
+export function hellingerDistance(p, q) {
+    if (p.length !== q.length || p.length === 0)
+        return 0;
+    const bc = bhattacharyyaCoefficient(p, q);
+    return Math.sqrt(1 - bc);
+}
+// Double Exponential Smoothing (Holt's method)
+export function doubleExponentialSmoothing(values, alpha = 0.3, beta = 0.1) {
+    if (values.length === 0)
+        return [];
+    const result = [];
+    let level = values[0] ?? 0;
+    let trend = 0;
+    result.push(level);
+    for (let i = 1; i < values.length; i++) {
+        const prevLevel = level;
+        level = alpha * values[i] + (1 - alpha) * (level + trend);
+        trend = beta * (level - prevLevel) + (1 - beta) * trend;
+        result.push(level + trend);
+    }
+    return result;
+}
+// Euler Characteristic (simplified for 2D)
+export function eulerCharacteristic(vertices, edges, faces) {
+    return vertices - edges + faces;
+}
+// Estimate Betti Numbers (simplified - returns basic topological invariants)
+export function estimateBettiNumbers(complex) {
+    const euler = eulerCharacteristic(complex.vertices, complex.edges, complex.faces);
+    // Simplified: b0 = number of connected components (assume 1 for now)
+    // b1 = edges - vertices + 1 (for a connected graph)
+    const b0 = 1;
+    const b1 = Math.max(0, complex.edges - complex.vertices + 1);
+    return { b0, b1 };
+}
+// Compactness measure
+export function compactness(area, perimeter) {
+    if (perimeter === 0)
+        return 0;
+    // 4π * area / perimeter^2 (circularity measure)
+    return (4 * Math.PI * area) / (perimeter * perimeter);
+}
+export function computeTerritoryStats(territories) {
+    if (territories.length === 0) {
+        return {
+            totalTerritories: 0,
+            averageSize: 0,
+            largestTerritory: 0,
+            smallestTerritory: 0,
+            compactness: 0,
+        };
+    }
+    const sizes = territories.map((t) => t.area);
+    const totalSize = sizes.reduce((sum, s) => sum + s, 0);
+    const avgCompactness = territories.reduce((sum, t) => sum + compactness(t.area, t.perimeter), 0) /
+        territories.length;
+    return {
+        totalTerritories: territories.length,
+        averageSize: totalSize / territories.length,
+        largestTerritory: Math.max(...sizes),
+        smallestTerritory: Math.min(...sizes),
+        compactness: avgCompactness,
+    };
+}

package/dist/algorithms/BayesianStatistics.d.ts

@@ -0,0 +1,86 @@
+export declare class BetaDistribution {
+    alpha: number;
+    beta: number;
+    constructor(alpha: number, beta: number);
+    mean(): number;
+    variance(): number;
+}
+export declare class MarkovChain {
+    private transitions;
+    addTransition(from: string, to: string): void;
+    probabilities(from: string): Array<{
+        to: string;
+        probability: number;
+    }>;
+}
+export declare class KalmanFilter {
+    private state;
+    private uncertainty;
+    private processNoise;
+    private measurementNoise;
+    constructor(initialState: number, initialUncertainty: number, processNoise: number, measurementNoise: number);
+    update(measurement: number): void;
+    step(): number;
+    predict(steps?: number): number;
+    forecast(steps: number): {
+        predictions: number[];
+        uncertainties: number[];
+    };
+    getState(): number;
+    getUncertainty(): number;
+}
+export declare function bayesianWinProbability(wins: number, losses: number): number;
+export declare function bayesianConquestRate(successes: number, trials: number): number;
+export declare function bayesianChangepoint(values: number[]): number;
+export interface ProbabilitySnapshot {
+    probabilities: Array<{
+        label: string;
+        probability: number;
+    }>;
+}
+export declare function generateProbabilitySnapshot(labels: string[]): ProbabilitySnapshot;
+export declare class DirichletDistribution {
+    private alphas;
+    constructor(alphas: number[]);
+    mean(): number[];
+}
+export declare class NormalDistribution {
+    private mean;
+    private variance;
+    constructor(mean: number, variance: number);
+    sample(): number;
+}
+export declare class PoissonDistribution {
+    private lambda;
+    constructor(lambda: number);
+    sample(): number;
+}
+export declare class ExponentialDistribution {
+    private lambda;
+    constructor(lambda: number);
+    sample(): number;
+}
+export declare class HiddenMarkovModel {
+    private states;
+    private transitions;
+    private emissions;
+    constructor(states: string[]);
+    addTransition(from: string, to: string, probability: number): void;
+    addEmission(state: string, observation: string, probability: number): void;
+}
+export declare function bayesianABTest(successA: number, trialsA: number, successB: number, trialsB: number): number;
+export declare function bayesFactor(priorOdds: number, likelihoodRatio: number): number;
+export declare function mapEstimate(data: number[], prior: {
+    alpha: number;
+    beta: number;
+}): number;
+export declare function learnMarkovChain(sequence: string[]): MarkovChain;
+export declare function bootstrapConfidenceInterval(data: number[], iterations?: number, confidence?: number): {
+    lower: number;
+    upper: number;
+};
+export declare function monteCarloIntegrate(fn: (x: number) => number, a: number, b: number, samples?: number): number;
+export declare function mutualInformation(x: number[], y: number[]): number;
+export declare function conditionalEntropy(x: number[], y: number[]): number;
+export declare function normalizedMutualInformation(x: number[], y: number[]): number;
+//# sourceMappingURL=BayesianStatistics.d.ts.map

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

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