@nshiab/simple-data-analysis-core 2.1.11 → 2.1.13

package/esm/helpers/cleanSQL.js

@@ -1,269 +0,0 @@
-import scanSQL from "./scanSQL.js";
-export default function cleanSQL(query, syntax = "js") {
-    if (syntax === "sql")
-        return query;
-    const tokens = scanSQL(query);
-    const significant = tokens.filter((token) => token.kind !== "trivia");
-    const original = significant.map((token) => token.kind === "sql" ? token.text.toUpperCase() : "");
-    const pairs = new Map();
-    const stack = [];
-    for (let i = 0; i < original.length; i++) {
-        if (["(", "[", "CASE"].includes(original[i]))
-            stack.push(i);
-        else if (stack.length &&
-            ((original[i] === ")" && original[stack[stack.length - 1]] === "(") ||
-                (original[i] === "]" && original[stack[stack.length - 1]] === "[") ||
-                (original[i] === "END" && original[stack[stack.length - 1]] === "CASE"))) {
-            const start = stack.pop();
-            pairs.set(start, i);
-            pairs.set(i, start);
-        }
-    }
-    const betweenAnd = new Set();
-    for (let i = 0; i < original.length; i++) {
-        if (original[i] !== "BETWEEN")
-            continue;
-        for (let j = i + 1; j < original.length; j++) {
-            if (["(", "[", "CASE"].includes(original[j])) {
-                j = pairs.get(j) ?? original.length;
-            }
-            else if ([")", "]", "END", ";"].includes(original[j]))
-                break;
-            else if (original[j] === "AND") {
-                betweenAnd.add(j);
-                break;
-            }
-        }
-    }
-    const comparisons = new Set([
-        "=",
-        "==",
-        "===",
-        "!=",
-        "!==",
-        "<>",
-        "<",
-        ">",
-        "<=",
-        ">=",
-        "IS",
-        "IN",
-        "LIKE",
-        "ILIKE",
-        "BETWEEN",
-    ]);
-    const boundaries = new Set([
-        "SELECT",
-        "FROM",
-        "WHERE",
-        "HAVING",
-        "QUALIFY",
-        "GROUP",
-        "ORDER",
-        "LIMIT",
-        "RETURNING",
-        "UNION",
-        "EXCEPT",
-        "INTERSECT",
-        "WHEN",
-        "THEN",
-        "ELSE",
-        "AS",
-        "AND",
-        "OR",
-        "&&",
-        ",",
-        ";",
-    ]);
-    const textTypes = new Set(["VARCHAR", "CHAR", "BPCHAR", "TEXT", "STRING"]);
-    function range(pipe, start, end, stop) {
-        let left = pipe - 1;
-        while (left >= start && !stop(left)) {
-            if ([")", "]", "END"].includes(original[left])) {
-                left = pairs.get(left) ?? start;
-            }
-            left--;
-        }
-        let right = pipe + 1;
-        while (right < end && !stop(right)) {
-            if (["(", "[", "CASE"].includes(original[right])) {
-                right = pairs.get(right) ?? end;
-            }
-            right++;
-        }
-        return [left + 1, right];
-    }
-    function predicate(start, end) {
-        if (original[start] === "(" && pairs.get(start) === end - 1) {
-            return predicate(start + 1, end - 1);
-        }
-        for (let i = start; i < end; i++) {
-            if (["(", "[", "CASE"].includes(original[i]))
-                i = pairs.get(i) ?? end;
-            else if (comparisons.has(original[i]))
-                return true;
-        }
-        return false;
-    }
-    // Only infer types that are explicit in the expression. Never infer a
-    // column's or an arbitrary function's type from its name or argument types.
-    function isTextType(start, end) {
-        return textTypes.has(original[start]) &&
-            (start + 1 === end ||
-                (original[start + 1] === "(" && pairs.get(start + 1) === end - 1));
-    }
-    function concatenable(start, end) {
-        if (start >= end)
-            return false;
-        let cast;
-        let pipe;
-        for (let i = start; i < end; i++) {
-            if (["(", "[", "CASE"].includes(original[i]))
-                i = pairs.get(i) ?? end;
-            else if (comparisons.has(original[i]))
-                return false;
-            else if (original[i] === "||")
-                pipe ??= i;
-            else if (original[i] === "::")
-                cast = i;
-        }
-        if (pipe !== undefined) {
-            return concatenable(start, pipe) || concatenable(pipe + 1, end);
-        }
-        // The final cast determines the result type, including casts to BOOLEAN.
-        if (cast !== undefined) {
-            return isTextType(cast + 1, end);
-        }
-        if (original[start] === "(" && pairs.get(start) === end - 1) {
-            return concatenable(start + 1, end - 1);
-        }
-        if (original[start] === "[" && pairs.get(start) === end - 1)
-            return true;
-        if (end === start + 1) {
-            return significant[start].kind === "quoted" &&
-                !significant[start].text.startsWith('"');
-        }
-        if (original[start + 1] === "(" && pairs.get(start + 1) === end - 1) {
-            if (["CONCAT", "CONCAT_WS"].includes(original[start]))
-                return true;
-            if (["CAST", "TRY_CAST"].includes(original[start])) {
-                for (let i = start + 2; i < end - 1; i++) {
-                    if (["(", "[", "CASE"].includes(original[i])) {
-                        i = pairs.get(i) ?? end;
-                    }
-                    else if (original[i] === "AS") {
-                        return isTextType(i + 1, end - 1);
-                    }
-                }
-            }
-        }
-        return false;
-    }
-    function obviousConcatenation(pipe, start, end) {
-        const [left, right] = range(pipe, start, end, (i) => (boundaries.has(original[i]) && !betweenAnd.has(i)) ||
-            original[i] === "||");
-        // A literal in a comparison is not evidence that the comparison returns text.
-        if (predicate(left, pipe) && predicate(pipe + 1, right))
-            return false;
-        const [groupStart, groupEnd] = range(pipe, start, end, (i) => boundaries.has(original[i]) || comparisons.has(original[i]));
-        let operand = groupStart;
-        for (let i = groupStart; i <= groupEnd; i++) {
-            if (["(", "[", "CASE"].includes(original[i])) {
-                i = pairs.get(i) ?? groupEnd;
-            }
-            else if (i === groupEnd || original[i] === "||") {
-                // Do not use the RHS literal of a preceding comparison to infer OR's
-                // meaning (text = 'a' || active). Other operands can still prove concat.
-                if (!(operand === groupStart &&
-                    (comparisons.has(original[groupStart - 1]) ||
-                        betweenAnd.has(groupStart - 1))) &&
-                    concatenable(operand, i))
-                    return true;
-                operand = i + 1;
-            }
-        }
-        return false;
-    }
-    function normalize(start, end) {
-        let statement = original[start];
-        let inSetClause = false;
-        let assignmentTarget = false;
-        for (let i = start; i < end; i++) {
-            const word = original[i];
-            if (statement === undefined)
-                statement = word;
-            // Nested queries are visited separately below. Look through statement
-            // prefixes to find the outer command that can introduce assignments.
-            if (["WITH", "EXPLAIN", "PREPARE"].includes(statement) &&
-                ["SELECT", "INSERT", "UPDATE", "DELETE", "MERGE"].includes(word))
-                statement = word;
-            if (word === "UPDATE" && ["DO", "THEN"].includes(original[i - 1]))
-                statement = word;
-            if (["(", "[", "CASE"].includes(word)) {
-                const close = pairs.get(i);
-                if (close !== undefined) {
-                    normalize(i + 1, close);
-                    i = close;
-                    continue;
-                }
-            }
-            if (["WHERE", "HAVING", "QUALIFY", "WHEN"].includes(word)) {
-                statement = word;
-                inSetClause = false;
-                assignmentTarget = false;
-            }
-            else if ([
-                "THEN",
-                "ELSE",
-                "SELECT",
-                "FROM",
-                "GROUP",
-                "ORDER",
-                "LIMIT",
-                "RETURNING",
-                "UNION",
-                "EXCEPT",
-                "INTERSECT",
-                ";",
-            ].includes(word)) {
-                statement = word;
-                inSetClause = false;
-                assignmentTarget = false;
-            }
-            else if (word === "SET" && !inSetClause &&
-                (statement === "UPDATE" ||
-                    (statement === "SET" &&
-                        (original[i + 1] === "VARIABLE" || original[i + 2] === "=")))) {
-                inSetClause = true;
-                assignmentTarget = true;
-            }
-            else if (word === "," && inSetClause)
-                assignmentTarget = true;
-            if (word === ";")
-                statement = undefined;
-            // Preserve only the assignment operator itself. Comparisons in its RHS
-            // still use shorthand, even when they are not wrapped in parentheses.
-            const assignment = assignmentTarget && ["=", "==", "==="].includes(word);
-            if (assignment)
-                assignmentTarget = false;
-            const token = significant[i];
-            if (["==", "==="].includes(word))
-                token.text = "=";
-            else if (word === "!==")
-                token.text = "!=";
-            else if (word === "&&")
-                token.text = " AND ";
-            else if (word === "||" && !obviousConcatenation(i, start, end)) {
-                token.text = " OR ";
-            }
-            if (original[i + 1] === "NULL" && !assignment) {
-                if (["=", "==", "==="].includes(word))
-                    token.text = " IS ";
-                else if (["!=", "!=="].includes(word))
-                    token.text = " IS NOT ";
-            }
-        }
-    }
-    normalize(0, significant.length);
-    return tokens.map((token) => token.text).join("").trim();
-}

package/esm/helpers/clusterHdbscan.d.ts

@@ -1,18 +0,0 @@
-import type { DuckDBConnection } from "@duckdb/node-api";
-/**
- * Build the condensed hierarchy, select EOM clusters, and calculate point
- * outputs from an HDBSCAN mutual-reachability MST. Only O(n) graph/hierarchy
- * state crosses from DuckDB; source vectors remain native.
- */
-export default function clusterHdbscan(connection: DuckDBConnection, mst: string, options: {
-    count: number;
-    minClusterSize: number;
-    allowSingleCluster: boolean;
-}): Promise<{
-    labels: Int32Array;
-    probabilities: Float64Array;
-    outlierScores: Float64Array;
-}>;
-/** Match a C float accumulator, including rounding after every addition. */
-export declare function accumulateFloat32(values: number[]): number;
-//# sourceMappingURL=clusterHdbscan.d.ts.map

package/esm/helpers/clusterHdbscan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clusterHdbscan.d.ts","sourceRoot":"","sources":["../../src/helpers/clusterHdbscan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAWzD;;;;GAIG;AACH,wBAA8B,cAAc,CAC1C,UAAU,EAAE,gBAAgB,EAC5B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;IACP,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,GACA,OAAO,CAAC;IACT,MAAM,EAAE,UAAU,CAAC;IACnB,aAAa,EAAE,YAAY,CAAC;IAC5B,aAAa,EAAE,YAAY,CAAC;CAC7B,CAAC,CAcD;AA4YD,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAI1D"}

package/esm/helpers/clusterHdbscan.js

@@ -1,342 +0,0 @@
-/**
- * Build the condensed hierarchy, select EOM clusters, and calculate point
- * outputs from an HDBSCAN mutual-reachability MST. Only O(n) graph/hierarchy
- * state crosses from DuckDB; source vectors remain native.
- */
-export default async function clusterHdbscan(connection, mst, options) {
-    // Leaves and internal nodes share the signed Int32 hierarchy namespace.
-    if (!Number.isSafeInteger(options.count) || options.count < 2 ||
-        options.count > 0x40000000) {
-        throw new Error("HDBSCAN hierarchy requires between 2 and 1073741824 rows so all 2*n-1 node identifiers fit signed INTEGER state.");
-    }
-    const edges = await readMst(connection, mst, options.count);
-    const linkage = buildSingleLinkage(edges, options.count);
-    const tree = condenseTree(linkage, options.count, options.minClusterSize);
-    return selectClusters(tree, options.count, options.allowSingleCluster);
-}
-async function readMst(connection, mst, count) {
-    const edges = [];
-    const result = await connection.stream(`SELECT source,target,distance FROM ${mst}`);
-    while (true) {
-        const chunk = await result.fetchChunk();
-        if (!chunk || chunk.rowCount === 0)
-            break;
-        const sources = chunk.getColumnVector(0);
-        const targets = chunk.getColumnVector(1);
-        const distances = chunk.getColumnVector(2);
-        for (let row = 0; row < chunk.rowCount; row++) {
-            const rawSource = sources.getItem(row);
-            const rawTarget = targets.getItem(row);
-            const rawDistance = distances.getItem(row);
-            if (rawSource === null || rawSource === undefined ||
-                rawTarget === null || rawTarget === undefined ||
-                rawDistance === null || rawDistance === undefined) {
-                throw new Error("HDBSCAN mutual-reachability MST contains an invalid edge.");
-            }
-            const source = Number(rawSource);
-            const target = Number(rawTarget);
-            const distance = Number(rawDistance);
-            if (!Number.isSafeInteger(source) || source < 0 || source >= count ||
-                !Number.isSafeInteger(target) || target < 0 || target >= count ||
-                source === target || !Number.isFinite(distance) || distance < 0) {
-                throw new Error("HDBSCAN mutual-reachability MST contains an invalid edge.");
-            }
-            edges.push({ source, target, distance });
-        }
-    }
-    if (edges.length !== count - 1) {
-        throw new Error(`HDBSCAN mutual-reachability MST returned ${edges.length} edges; ${count - 1} were required.`);
-    }
-    return edges;
-}
-function buildSingleLinkage(edges, count) {
-    edges.sort((a, b) => a.distance - b.distance ||
-        Math.min(a.source, a.target) - Math.min(b.source, b.target) ||
-        Math.max(a.source, a.target) - Math.max(b.source, b.target));
-    const parent = new Int32Array(count);
-    const size = new Int32Array(count).fill(1);
-    const node = new Int32Array(count);
-    for (let vertex = 0; vertex < count; vertex++) {
-        parent[vertex] = vertex;
-        node[vertex] = vertex;
-    }
-    const find = (start) => {
-        let root = start;
-        while (parent[root] !== root)
-            root = parent[root];
-        let current = start;
-        while (parent[current] !== current) {
-            const next = parent[current];
-            parent[current] = root;
-            current = next;
-        }
-        return root;
-    };
-    const linkage = [];
-    for (const edge of edges) {
-        let leftRoot = find(edge.source);
-        let rightRoot = find(edge.target);
-        if (leftRoot === rightRoot) {
-            throw new Error("HDBSCAN mutual-reachability edges do not form a tree.");
-        }
-        const combinedNode = count + linkage.length;
-        const combinedSize = size[leftRoot] + size[rightRoot];
-        linkage.push({
-            left: node[leftRoot],
-            right: node[rightRoot],
-            distance: edge.distance,
-            size: combinedSize,
-        });
-        if (size[leftRoot] < size[rightRoot]) {
-            [leftRoot, rightRoot] = [rightRoot, leftRoot];
-        }
-        parent[rightRoot] = leftRoot;
-        size[leftRoot] = combinedSize;
-        node[leftRoot] = combinedNode;
-    }
-    if (linkage.length !== count - 1 || linkage.at(-1)?.size !== count) {
-        throw new Error("HDBSCAN mutual-reachability edges do not form one connected tree.");
-    }
-    return linkage;
-}
-function condenseTree(hierarchy, count, minClusterSize) {
-    const root = 2 * count - 2;
-    const relabel = new Int32Array(root + 1).fill(-1);
-    relabel[root] = count;
-    let nextLabel = count + 1;
-    const ignored = new Uint8Array(root + 1);
-    const result = [];
-    for (const current of breadthFirstHierarchy(hierarchy, count, root)) {
-        if (ignored[current] || current < count)
-            continue;
-        const split = hierarchy[current - count];
-        const lambda = split.distance > 0 ? 1 / split.distance : Infinity;
-        const leftSize = split.left >= count
-            ? hierarchy[split.left - count].size
-            : 1;
-        const rightSize = split.right >= count
-            ? hierarchy[split.right - count].size
-            : 1;
-        if (leftSize >= minClusterSize && rightSize >= minClusterSize) {
-            relabel[split.left] = nextLabel++;
-            result.push({
-                parent: relabel[current],
-                child: relabel[split.left],
-                lambda,
-                childSize: leftSize,
-            });
-            relabel[split.right] = nextLabel++;
-            result.push({
-                parent: relabel[current],
-                child: relabel[split.right],
-                lambda,
-                childSize: rightSize,
-            });
-        }
-        else if (leftSize < minClusterSize && rightSize < minClusterSize) {
-            appendRunt(hierarchy, count, split.left, relabel[current], lambda, ignored, result);
-            appendRunt(hierarchy, count, split.right, relabel[current], lambda, ignored, result);
-        }
-        else if (leftSize < minClusterSize) {
-            relabel[split.right] = relabel[current];
-            appendRunt(hierarchy, count, split.left, relabel[current], lambda, ignored, result);
-        }
-        else {
-            relabel[split.left] = relabel[current];
-            appendRunt(hierarchy, count, split.right, relabel[current], lambda, ignored, result);
-        }
-    }
-    if (result.length === 0) {
-        throw new Error("HDBSCAN condensed hierarchy is empty.");
-    }
-    return result;
-}
-function appendRunt(hierarchy, count, root, parent, lambda, ignored, result) {
-    for (const node of breadthFirstHierarchy(hierarchy, count, root)) {
-        if (node < count) {
-            result.push({ parent, child: node, lambda, childSize: 1 });
-        }
-        ignored[node] = 1;
-    }
-}
-function breadthFirstHierarchy(hierarchy, count, root) {
-    const result = [];
-    let level = [root];
-    while (level.length > 0) {
-        for (const node of level)
-            result.push(node);
-        const next = [];
-        for (const node of level) {
-            if (node < count)
-                continue;
-            const split = hierarchy[node - count];
-            next.push(split.left, split.right);
-        }
-        level = next;
-    }
-    return result;
-}
-function selectClusters(tree, count, allowSingleCluster) {
-    let root = Number.MAX_SAFE_INTEGER;
-    let maximumParent = -1;
-    for (const edge of tree) {
-        if (edge.parent < root)
-            root = edge.parent;
-        if (edge.parent > maximumParent)
-            maximumParent = edge.parent;
-    }
-    if (root !== count) {
-        throw new Error("HDBSCAN condensed hierarchy has an invalid root.");
-    }
-    const births = new Float64Array(maximumParent + 1).fill(NaN);
-    for (const edge of tree) {
-        if (Number.isNaN(births[edge.child]))
-            births[edge.child] = edge.lambda;
-        else
-            births[edge.child] = Math.min(births[edge.child], edge.lambda);
-    }
-    births[root] = 0;
-    const stability = new Map();
-    for (let cluster = root; cluster <= maximumParent; cluster++) {
-        stability.set(cluster, 0);
-    }
-    for (const edge of tree) {
-        stability.set(edge.parent, stability.get(edge.parent) +
-            (edge.lambda - births[edge.parent]) * edge.childSize);
-    }
-    const clusterEdges = tree.filter(({ childSize }) => childSize > 1);
-    const nodeList = [...stability.keys()].sort((a, b) => b - a);
-    if (!allowSingleCluster)
-        nodeList.pop();
-    const preferred = new Map();
-    const children = new Map();
-    for (const edge of clusterEdges) {
-        const values = children.get(edge.parent) ?? [];
-        values.push(edge.child);
-        children.set(edge.parent, values);
-    }
-    for (const cluster of nodeList) {
-        const childClusters = children.get(cluster) ?? [];
-        // hdbscan 0.8.44 stores this otherwise-double reduction in a C float.
-        const subtreeStability = accumulateFloat32(childClusters.map((child) => stability.get(child)));
-        if (subtreeStability > stability.get(cluster)) {
-            stability.set(cluster, subtreeStability);
-            preferred.set(cluster, false);
-        }
-        else {
-            preferred.set(cluster, true);
-        }
-    }
-    const clusters = [];
-    const pending = [root];
-    while (pending.length > 0) {
-        const cluster = pending.pop();
-        if ((cluster !== root || allowSingleCluster) && preferred.get(cluster)) {
-            clusters.push(cluster);
-            continue;
-        }
-        const childClusters = children.get(cluster) ?? [];
-        for (let index = childClusters.length - 1; index >= 0; index--) {
-            pending.push(childClusters[index]);
-        }
-    }
-    clusters.sort((a, b) => a - b);
-    const labelsByCluster = new Map(clusters.map((cluster, label) => [cluster, label]));
-    const pointEdges = new Array(count);
-    const parentByCluster = new Map();
-    for (const edge of tree) {
-        if (edge.child < count)
-            pointEdges[edge.child] = edge;
-        else
-            parentByCluster.set(edge.child, edge.parent);
-    }
-    for (let point = 0; point < count; point++) {
-        if (pointEdges[point] === undefined) {
-            throw new Error("HDBSCAN condensed hierarchy omitted an input row.");
-        }
-    }
-    const labels = new Int32Array(count).fill(-1);
-    const selectedAncestor = new Int32Array(maximumParent + 1).fill(-1);
-    for (let cluster = root; cluster <= maximumParent; cluster++) {
-        if (labelsByCluster.has(cluster)) {
-            selectedAncestor[cluster] = cluster;
-            continue;
-        }
-        const parent = parentByCluster.get(cluster);
-        if (parent !== undefined) {
-            selectedAncestor[cluster] = selectedAncestor[parent];
-        }
-    }
-    let rootExit = 0;
-    for (const edge of tree) {
-        if (edge.parent === root && edge.lambda > rootExit)
-            rootExit = edge.lambda;
-    }
-    for (let point = 0; point < count; point++) {
-        const pointEdge = pointEdges[point];
-        const cluster = selectedAncestor[pointEdge.parent];
-        if (cluster < 0)
-            continue;
-        if (cluster === root &&
-            !(clusters.length === 1 && allowSingleCluster &&
-                pointEdge.lambda >= rootExit))
-            continue;
-        labels[point] = labelsByCluster.get(cluster);
-    }
-    const deaths = directMaximumLambdas(tree, maximumParent);
-    const probabilities = new Float64Array(count);
-    for (let point = 0; point < count; point++) {
-        const label = labels[point];
-        if (label < 0)
-            continue;
-        const cluster = clusters[label];
-        const maximum = deaths[cluster];
-        const lambda = pointEdges[point].lambda;
-        probabilities[point] = maximum === 0 || !Number.isFinite(lambda)
-            ? 1
-            : Math.min(lambda, maximum) / maximum;
-    }
-    // hdbscan 0.8.44 propagates maximum density through the condensed tree in
-    // reverse edge order, so each parent sees maxima already resolved below it.
-    for (let index = tree.length - 1; index >= 0; index--) {
-        const edge = tree[index];
-        if (deaths[edge.child] > deaths[edge.parent]) {
-            deaths[edge.parent] = deaths[edge.child];
-        }
-    }
-    const outlierScores = new Float64Array(count);
-    for (let point = 0; point < count; point++) {
-        const edge = pointEdges[point];
-        const maximum = deaths[edge.parent];
-        if (maximum === 0 || !Number.isFinite(edge.lambda)) {
-            outlierScores[point] = 0;
-        }
-        else if (!Number.isFinite(maximum)) {
-            // hdbscan 0.8.44 returns NaN for (Infinity - finite) / Infinity.
-            // Use the finite perturbation limit so public outputs remain finite.
-            outlierScores[point] = 1;
-        }
-        else {
-            outlierScores[point] = (maximum - edge.lambda) / maximum;
-        }
-    }
-    if (probabilities.some((value) => !Number.isFinite(value)) ||
-        outlierScores.some((value) => !Number.isFinite(value))) {
-        throw new Error("HDBSCAN produced non-finite point scores.");
-    }
-    return { labels, probabilities, outlierScores };
-}
-/** Match a C float accumulator, including rounding after every addition. */
-export function accumulateFloat32(values) {
-    let total = 0;
-    for (const value of values)
-        total = Math.fround(total + value);
-    return total;
-}
-function directMaximumLambdas(tree, maximumParent) {
-    const deaths = new Float64Array(maximumParent + 1);
-    for (const edge of tree) {
-        deaths[edge.parent] = Math.max(deaths[edge.parent], edge.lambda);
-    }
-    return deaths;
-}

package/esm/helpers/computeCovariance.d.ts

@@ -1,16 +0,0 @@
-import type { DuckDBConnection } from "@duckdb/node-api";
-import { type CovarianceFactor } from "./factorCovariance.js";
-export type CovarianceModel = CovarianceFactor & {
-    means: Float64Array;
-    origins: Float64Array;
-    meanOffsets: Float64Array;
-    observations: number;
-};
-export default function computeCovariance(connection: DuckDBConnection, input: {
-    relation: string;
-    rowIdColumn: string;
-    vectorColumn: string;
-    observations: number;
-    dimensions: number;
-}): Promise<CovarianceModel>;
-//# sourceMappingURL=computeCovariance.d.ts.map

package/esm/helpers/computeCovariance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computeCovariance.d.ts","sourceRoot":"","sources":["../../src/helpers/computeCovariance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,uBAAuB,CAAC;AAEhF,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG;IAC/C,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,YAAY,CAAC;IACtB,WAAW,EAAE,YAAY,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAA8B,iBAAiB,CAC7C,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE;IACL,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,GACA,OAAO,CAAC,eAAe,CAAC,CAmH1B"}