df-script 1.4.0

package/dist/columnExpressions/mixins/ComparisonExpr.d.ts

@@ -0,0 +1,60 @@
+import type { ExprConstructor } from "../types";
+export declare const ComparisonExpr: <TBase extends ExprConstructor>(Base: TBase) => {
+    new (...args: any[]): {
+        between(lower: any, upper: any, closed?: "both" | "left" | "right" | "none"): /*elided*/ any;
+        eq(val: any): /*elided*/ any;
+        eq_missing(val: any): /*elided*/ any;
+        ge(val: any): /*elided*/ any;
+        gt(val: any): /*elided*/ any;
+        has_nulls(): any;
+        is_close(other: any, options?: {
+            abs_tol?: number;
+            rel_tol?: number;
+            nans_equal?: boolean;
+        }): /*elided*/ any;
+        is_duplicated(): /*elided*/ any;
+        is_empty(options?: {
+            ignoreNulls?: boolean;
+        }): /*elided*/ any;
+        is_finite(): /*elided*/ any;
+        is_first_distinct(): /*elided*/ any;
+        is_in(values: any[] | any): /*elided*/ any;
+        is_infinite(): /*elided*/ any;
+        is_last_distinct(): /*elided*/ any;
+        is_n_distinct(n: number): any;
+        is_nan(): /*elided*/ any;
+        is_not_nan(): /*elided*/ any;
+        is_not_null(): /*elided*/ any;
+        is_null(): /*elided*/ any;
+        is_unique(): /*elided*/ any;
+        le(val: any): /*elided*/ any;
+        lt(val: any): /*elided*/ any;
+        ne(val: any): /*elided*/ any;
+        ne_missing(val: any): /*elided*/ any;
+        not_in(values: any[] | any): /*elided*/ any;
+        ops: import("../..").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        aggFn?: import("../..").AggFn<any> | null;
+        groupingOpsIndex?: number;
+        partitionOpsIndex?: number;
+        partitionBy?: (string | import("../..").IExpr)[] | null;
+        windowOp?: {
+            type: string;
+            [key: string]: any;
+        } | null;
+        isWindow?: boolean;
+        alias(name: string): /*elided*/ any;
+        cast(dataType: any): /*elided*/ any;
+        _resolve(val: any, columns: import("../..").ColumnDict, height: number): import("../..").ColumnData | any;
+        evaluate(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePreGrouping(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePostGrouping(aggregatedArray: any[], columns: import("../..").ColumnDict): import("../..").ColumnData;
+        evaluatePrePartition(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePostPartition(aggregatedArray: any[], columns: import("../..").ColumnDict): import("../..").ColumnData;
+        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
+        debug(label?: string): /*elided*/ any;
+    };
+} & TBase;

package/dist/columnExpressions/mixins/ComparisonExpr.js

@@ -0,0 +1,389 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComparisonExpr = void 0;
+const ExprBase_1 = require("../ExprBase");
+const utils_1 = require("../../utils");
+function getCacheKey(val) {
+    if (val == null) {
+        return val;
+    }
+    if (val instanceof Date) {
+        return `d:${val.getTime()}`;
+    }
+    if (val instanceof Uint8Array) {
+        return `u:${val.toString()}`;
+    }
+    if (typeof val === "object" || typeof val === "function") {
+        return String(val);
+    }
+    return val;
+}
+const ComparisonExpr = (Base) => {
+    return class extends Base {
+        between(lower, upper, closed = "both") {
+            return (0, ExprBase_1.derive)(this, (vArray, columns) => {
+                const height = vArray.length;
+                const lResolved = this._resolve(lower, columns, height);
+                const uResolved = this._resolve(upper, columns, height);
+                const result = new Array(height);
+                const isLArray = (0, utils_1.isArrayOrTypedArray)(lResolved);
+                const isUArray = (0, utils_1.isArrayOrTypedArray)(uResolved);
+                for (let i = 0; i < height; i++) {
+                    const v = vArray[i];
+                    const l = isLArray ? lResolved[i] : lResolved;
+                    const u = isUArray ? uResolved[i] : uResolved;
+                    if (v == null || l == null || u == null) {
+                        result[i] = null;
+                    }
+                    else {
+                        const geLower = closed === "both" || closed === "left" ? v >= l : v > l;
+                        const leUpper = closed === "both" || closed === "right" ? v <= u : v < u;
+                        result[i] = geLower && leUpper;
+                    }
+                }
+                return result;
+            });
+        }
+        eq(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => v === r));
+        }
+        eq_missing(val) {
+            return (0, ExprBase_1.derive)(this, (vArray, columns) => {
+                const height = vArray.length;
+                const rResolved = this._resolve(val, columns, height);
+                const result = new Array(height);
+                if ((0, utils_1.isArrayOrTypedArray)(rResolved)) {
+                    for (let i = 0; i < height; i++) {
+                        const v = vArray[i];
+                        const r = rResolved[i];
+                        if (v == null && r == null)
+                            result[i] = true;
+                        else if (v == null || r == null)
+                            result[i] = false;
+                        else
+                            result[i] = v === r;
+                    }
+                }
+                else {
+                    for (let i = 0; i < height; i++) {
+                        const v = vArray[i];
+                        if (v == null && rResolved == null)
+                            result[i] = true;
+                        else if (v == null || rResolved == null)
+                            result[i] = false;
+                        else
+                            result[i] = v === rResolved;
+                    }
+                }
+                return result;
+            });
+        }
+        ge(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => v >= r));
+        }
+        gt(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => v > r));
+        }
+        has_nulls() {
+            return this._deriveAgg((v) => {
+                for (let i = 0; i < v.length; i++) {
+                    if (v[i] == null)
+                        return true;
+                }
+                return false;
+            });
+        }
+        is_close(other, options = {}) {
+            const { abs_tol = 1e-8, rel_tol = 1e-8, nans_equal = false } = options;
+            return (0, ExprBase_1.derive)(this, (vArray, columns) => {
+                const height = vArray.length;
+                const otherVal = this._resolve(other, columns, height);
+                const isOtherArray = (0, utils_1.isArrayOrTypedArray)(otherVal);
+                const result = new Array(height);
+                for (let i = 0; i < height; i++) {
+                    const v = vArray[i];
+                    const o = isOtherArray ? otherVal[i] : otherVal;
+                    if (v == null || o == null) {
+                        result[i] = null;
+                    }
+                    else if (Number.isNaN(v) || Number.isNaN(o)) {
+                        if (nans_equal && Number.isNaN(v) && Number.isNaN(o)) {
+                            result[i] = true;
+                        }
+                        else {
+                            result[i] = false;
+                        }
+                    }
+                    else if (!Number.isFinite(v) || !Number.isFinite(o)) {
+                        result[i] = (v === o);
+                    }
+                    else {
+                        const absDiff = Math.abs(v - o);
+                        const threshold = Math.max(rel_tol * Math.max(Math.abs(v), Math.abs(o)), abs_tol);
+                        result[i] = absDiff <= threshold;
+                    }
+                }
+                return result;
+            });
+        }
+        is_duplicated() {
+            return (0, ExprBase_1.derive)(this, (vArray) => {
+                const height = vArray.length;
+                const counts = new Map();
+                const keys = new Array(height);
+                for (let i = 0; i < height; i++) {
+                    const k = getCacheKey(vArray[i]);
+                    keys[i] = k;
+                    counts.set(k, (counts.get(k) || 0) + 1);
+                }
+                const result = new Array(height);
+                for (let i = 0; i < height; i++) {
+                    result[i] = (counts.get(keys[i]) || 0) > 1;
+                }
+                return result;
+            });
+        }
+        is_empty(options = {}) {
+            const { ignoreNulls = false } = options;
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => {
+                if (typeof v === "string") {
+                    return v.length === 0;
+                }
+                if ((0, utils_1.isArrayOrTypedArray)(v)) {
+                    if (ignoreNulls) {
+                        const len = v.length;
+                        let nonNullCount = 0;
+                        for (let i = 0; i < len; i++) {
+                            if (v[i] != null) {
+                                nonNullCount++;
+                            }
+                        }
+                        return nonNullCount === 0;
+                    }
+                    return v.length === 0;
+                }
+                return null;
+            }));
+        }
+        is_finite() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Number.isFinite));
+        }
+        is_first_distinct() {
+            return (0, ExprBase_1.derive)(this, (vArray) => {
+                const height = vArray.length;
+                const seen = new Set();
+                const result = new Array(height);
+                for (let i = 0; i < height; i++) {
+                    const k = getCacheKey(vArray[i]);
+                    if (seen.has(k)) {
+                        result[i] = false;
+                    }
+                    else {
+                        seen.add(k);
+                        result[i] = true;
+                    }
+                }
+                return result;
+            });
+        }
+        is_in(values) {
+            return (0, ExprBase_1.derive)(this, (vArray, columns) => {
+                const height = vArray.length;
+                const result = new Array(height);
+                if (values && typeof values === 'object' && 'evaluate' in values) {
+                    const resolved = values.evaluate(columns, height);
+                    for (let i = 0; i < height; i++) {
+                        const v = vArray[i];
+                        if (v == null) {
+                            result[i] = null;
+                        }
+                        else {
+                            const candidates = resolved[i];
+                            const set = new Set();
+                            if ((0, utils_1.isArrayOrTypedArray)(candidates)) {
+                                const cLen = candidates.length;
+                                for (let j = 0; j < cLen; j++) {
+                                    set.add(getCacheKey(candidates[j]));
+                                }
+                            }
+                            else {
+                                set.add(getCacheKey(candidates));
+                            }
+                            result[i] = set.has(getCacheKey(v));
+                        }
+                    }
+                }
+                else {
+                    const arr = (0, utils_1.isArrayOrTypedArray)(values) ? values : [];
+                    const set = new Set();
+                    const arrLen = arr.length;
+                    for (let j = 0; j < arrLen; j++) {
+                        set.add(getCacheKey(arr[j]));
+                    }
+                    for (let i = 0; i < height; i++) {
+                        const v = vArray[i];
+                        result[i] = v == null ? null : set.has(getCacheKey(v));
+                    }
+                }
+                return result;
+            });
+        }
+        is_infinite() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => v === Infinity || v === -Infinity));
+        }
+        is_last_distinct() {
+            return (0, ExprBase_1.derive)(this, (vArray) => {
+                const height = vArray.length;
+                const seen = new Set();
+                const result = new Array(height);
+                for (let i = height - 1; i >= 0; i--) {
+                    const k = getCacheKey(vArray[i]);
+                    if (seen.has(k)) {
+                        result[i] = false;
+                    }
+                    else {
+                        seen.add(k);
+                        result[i] = true;
+                    }
+                }
+                return result;
+            });
+        }
+        is_n_distinct(n) {
+            return this._deriveAgg((v) => {
+                const set = new Set();
+                const len = v.length;
+                for (let i = 0; i < len; i++) {
+                    set.add(getCacheKey(v[i]));
+                }
+                return set.size === n;
+            });
+        }
+        is_nan() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Number.isNaN));
+        }
+        is_not_nan() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => !Number.isNaN(v)));
+        }
+        is_not_null() {
+            return (0, ExprBase_1.derive)(this, (vArray) => {
+                const height = vArray.length;
+                const result = new Array(height);
+                for (let i = 0; i < height; i++) {
+                    result[i] = vArray[i] != null;
+                }
+                return result;
+            });
+        }
+        is_null() {
+            return (0, ExprBase_1.derive)(this, (vArray) => {
+                const height = vArray.length;
+                const result = new Array(height);
+                for (let i = 0; i < height; i++) {
+                    result[i] = vArray[i] == null;
+                }
+                return result;
+            });
+        }
+        is_unique() {
+            return (0, ExprBase_1.derive)(this, (vArray) => {
+                const height = vArray.length;
+                const counts = new Map();
+                const keys = new Array(height);
+                for (let i = 0; i < height; i++) {
+                    const k = getCacheKey(vArray[i]);
+                    keys[i] = k;
+                    counts.set(k, (counts.get(k) || 0) + 1);
+                }
+                const result = new Array(height);
+                for (let i = 0; i < height; i++) {
+                    result[i] = counts.get(keys[i]) === 1;
+                }
+                return result;
+            });
+        }
+        le(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => v <= r));
+        }
+        lt(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => v < r));
+        }
+        ne(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => v !== r));
+        }
+        ne_missing(val) {
+            return (0, ExprBase_1.derive)(this, (vArray, columns) => {
+                const height = vArray.length;
+                const rResolved = this._resolve(val, columns, height);
+                const result = new Array(height);
+                if ((0, utils_1.isArrayOrTypedArray)(rResolved)) {
+                    for (let i = 0; i < height; i++) {
+                        const v = vArray[i];
+                        const r = rResolved[i];
+                        if (v == null && r == null)
+                            result[i] = false;
+                        else if (v == null || r == null)
+                            result[i] = true;
+                        else
+                            result[i] = v !== r;
+                    }
+                }
+                else {
+                    for (let i = 0; i < height; i++) {
+                        const v = vArray[i];
+                        if (v == null && rResolved == null)
+                            result[i] = false;
+                        else if (v == null || rResolved == null)
+                            result[i] = true;
+                        else
+                            result[i] = v !== rResolved;
+                    }
+                }
+                return result;
+            });
+        }
+        not_in(values) {
+            return (0, ExprBase_1.derive)(this, (vArray, columns) => {
+                const height = vArray.length;
+                const result = new Array(height);
+                if (values && typeof values === 'object' && 'evaluate' in values) {
+                    const resolved = values.evaluate(columns, height);
+                    for (let i = 0; i < height; i++) {
+                        const v = vArray[i];
+                        if (v == null) {
+                            result[i] = null;
+                        }
+                        else {
+                            const candidates = resolved[i];
+                            const set = new Set();
+                            if ((0, utils_1.isArrayOrTypedArray)(candidates)) {
+                                const cLen = candidates.length;
+                                for (let j = 0; j < cLen; j++) {
+                                    set.add(getCacheKey(candidates[j]));
+                                }
+                            }
+                            else {
+                                set.add(getCacheKey(candidates));
+                            }
+                            result[i] = !set.has(getCacheKey(v));
+                        }
+                    }
+                }
+                else {
+                    const arr = (0, utils_1.isArrayOrTypedArray)(values) ? values : [];
+                    const set = new Set();
+                    const arrLen = arr.length;
+                    for (let j = 0; j < arrLen; j++) {
+                        set.add(getCacheKey(arr[j]));
+                    }
+                    for (let i = 0; i < height; i++) {
+                        const v = vArray[i];
+                        result[i] = v == null ? null : !set.has(getCacheKey(v));
+                    }
+                }
+                return result;
+            });
+        }
+    };
+};
+exports.ComparisonExpr = ComparisonExpr;

package/dist/columnExpressions/mixins/ListExpr.d.ts

@@ -0,0 +1,63 @@
+import type { ExprConstructor } from "../types";
+export declare class ListExprNamespace {
+    expr: any;
+    constructor(expr: any);
+    _deriveList(fn: (arr: any[] | ArrayBufferView) => any): any;
+    all(): any;
+    any(): any;
+    contains(item: any): any;
+    contains_all(items: any[]): any;
+    contains_any(items: any[]): any;
+    count_matches(item: any): any;
+    drop_nulls(): any;
+    first(null_on_oob?: boolean): any;
+    gather(indices: number | number[], null_on_oob?: boolean): any;
+    gather_every(n: number, offset?: number): any;
+    get(index: number, null_on_oob?: boolean): any;
+    join(separator: string, { ignoreNulls }?: {
+        ignoreNulls?: boolean;
+    }): any;
+    last(null_on_oob?: boolean): any;
+    len(): any;
+    lengths(): any;
+    max(): any;
+    mean(): any;
+    median(): any;
+    min(): any;
+    mode(): any;
+    n_unique(): any;
+    reverse(): any;
+    slice(offset: number, length?: number): any;
+    sort(descending?: boolean): any;
+    sum(): any;
+    unique(): any;
+}
+export declare const ListExpr: <TBase extends ExprConstructor>(Base: TBase) => {
+    new (...args: any[]): {
+        get list(): ListExprNamespace;
+        ops: import("../..").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        aggFn?: import("../..").AggFn<any> | null;
+        groupingOpsIndex?: number;
+        partitionOpsIndex?: number;
+        partitionBy?: (string | import("../..").IExpr)[] | null;
+        windowOp?: {
+            type: string;
+            [key: string]: any;
+        } | null;
+        isWindow?: boolean;
+        alias(name: string): /*elided*/ any;
+        cast(dataType: any): /*elided*/ any;
+        _resolve(val: any, columns: import("../..").ColumnDict, height: number): import("../..").ColumnData | any;
+        evaluate(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePreGrouping(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePostGrouping(aggregatedArray: any[], columns: import("../..").ColumnDict): import("../..").ColumnData;
+        evaluatePrePartition(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePostPartition(aggregatedArray: any[], columns: import("../..").ColumnDict): import("../..").ColumnData;
+        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
+        debug(label?: string): /*elided*/ any;
+    };
+} & TBase;