df-script 1.4.0 → 1.5.0

package/dist/columnExpressions/mixins/ManipulationExpr.js

@@ -3,33 +3,69 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManipulationExpr = void 0;
 const ExprBase_1 = require("../ExprBase");
 const utils_1 = require("../../utils");
-const ManipulationExpr = (Base) => {
-    return class extends Base {
-        fill_null(value) {
-            return (0, ExprBase_1.derive)(this, (vArray, columns) => {
-                const height = vArray.length;
-                const resolved = this._resolve(value, columns, height);
-                const result = new Array(height);
-                if ((0, utils_1.isArrayOrTypedArray)(resolved)) {
-                    for (let i = 0; i < height; i++) {
-                        const v = vArray[i];
-                        result[i] = v == null ? resolved[i] : v;
+class ManipulationExpr extends ExprBase_1.ExprBase {
+    fill_null({ value = undefined, strategy = undefined, limit = undefined } = {}) {
+        return (0, ExprBase_1.derive)(this, (vArray, columns) => {
+            const height = vArray.length;
+            const result = Array.from(vArray);
+            if (strategy !== undefined) {
+                if (strategy === "zero" || strategy === "one" || strategy === "min" || strategy === "max" || strategy === "mean") {
+                    let fillVal;
+                    if (strategy === "zero") {
+                        fillVal = 0;
+                    }
+                    else if (strategy === "one") {
+                        fillVal = 1;
+                    }
+                    else {
+                        const stats = (0, utils_1.getListStats)(vArray);
+                        fillVal = stats[strategy];
                     }
+                    (0, utils_1.fillSequence)(result, fillVal, {
+                        mode: "constant",
+                        condition: (v) => v == null
+                    });
+                }
+                else if (strategy === "forward" || strategy === "backward") {
+                    const isForward = strategy === "forward";
+                    let lastVal = null;
+                    let consecCount = 0;
+                    (0, utils_1.fillSequence)(result, null, {
+                        mode: "independent",
+                        reverse: !isForward,
+                        step: ({ originalValue }) => {
+                            if (originalValue != null) {
+                                lastVal = originalValue;
+                                consecCount = 0;
+                                return originalValue;
+                            }
+                            if (lastVal !== null && (limit === undefined || consecCount < limit)) {
+                                consecCount++;
+                                return lastVal;
+                            }
+                            return null;
+                        }
+                    });
                 }
                 else {
-                    for (let i = 0; i < height; i++) {
-                        const v = vArray[i];
-                        result[i] = v == null ? resolved : v;
-                    }
+                    throw new Error(`Unsupported fill_null strategy: "${strategy}"`);
                 }
-                return result;
-            });
-        }
-        reverse() {
-            return (0, ExprBase_1.derive)(this, (vArray) => {
-                return vArray.slice().reverse();
-            });
-        }
-    };
-};
+            }
+            else {
+                const resolved = this._resolve(value, columns, height);
+                const isArr = (0, utils_1.isArrayOrTypedArray)(resolved);
+                (0, utils_1.fillSequence)(result, null, {
+                    mode: "independent",
+                    step: ({ index, originalValue }) => originalValue == null ? (isArr ? resolved[index] : resolved) : originalValue
+                });
+            }
+            return result;
+        });
+    }
+    reverse() {
+        return (0, ExprBase_1.derive)(this, (vArray) => {
+            return vArray.slice().reverse();
+        });
+    }
+}
 exports.ManipulationExpr = ManipulationExpr;

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

@@ -0,0 +1,92 @@
+import type { IExpr } from "../../types";
+import type { ExprConstructor, RandomOptions } from "../types";
+export declare const NumericExpr: <TBase extends ExprConstructor>(Base: TBase) => {
+    new (...args: any[]): {
+        abs(): /*elided*/ any;
+        acos(): /*elided*/ any;
+        acosh(): /*elided*/ any;
+        add(val: number | IExpr | null): /*elided*/ any;
+        asin(): /*elided*/ any;
+        asinh(): /*elided*/ any;
+        atan(): /*elided*/ any;
+        atanh(): /*elided*/ any;
+        cbrt(): /*elided*/ any;
+        ceil(): /*elided*/ any;
+        clip(lower?: number | null, upper?: number | null): /*elided*/ any;
+        cos(): /*elided*/ any;
+        cosh(): /*elided*/ any;
+        degrees(): /*elided*/ any;
+        div(val: number | IExpr | null): /*elided*/ any;
+        exp(): /*elided*/ any;
+        expm1(): /*elided*/ any;
+        floor(): /*elided*/ any;
+        floordiv(val: number | IExpr | null): /*elided*/ any;
+        hypot(val: number | IExpr | null): /*elided*/ any;
+        log(base?: number): /*elided*/ any;
+        log1p(): /*elided*/ any;
+        mod(val: number | IExpr | null): /*elided*/ any;
+        mul(val: number | IExpr | null): /*elided*/ any;
+        negate(): /*elided*/ any;
+        pow(val: number | IExpr | null): /*elided*/ any;
+        radians(): /*elided*/ any;
+        rand(seed?: number, { min, max, integer }?: RandomOptions): /*elided*/ any;
+        round(decimals?: number): /*elided*/ any;
+        sign(): /*elided*/ any;
+        sin(): /*elided*/ any;
+        sinh(): /*elided*/ any;
+        sqrt(): /*elided*/ any;
+        sub(val: number | IExpr | null): /*elided*/ any;
+        tan(): /*elided*/ any;
+        tanh(): /*elided*/ any;
+        trunc(): /*elided*/ any;
+        avg(): /*elided*/ any;
+        mean(): /*elided*/ any;
+        sum(): /*elided*/ any;
+        std(): /*elided*/ any;
+        min(): /*elided*/ any;
+        max(): /*elided*/ any;
+        median(): /*elided*/ any;
+        quantile(q: number): /*elided*/ any;
+        count(options?: {
+            includeNulls?: boolean;
+        }): /*elided*/ any;
+        cum_max(reverse?: boolean): /*elided*/ any;
+        cum_min(reverse?: boolean): /*elided*/ any;
+        cum_prod(reverse?: boolean): /*elided*/ any;
+        cum_sum(reverse?: boolean): /*elided*/ any;
+        rolling_max(windowSize: number): /*elided*/ any;
+        rolling_mean(windowSize: number): /*elided*/ any;
+        rolling_median(windowSize: number): /*elided*/ any;
+        rolling_min(windowSize: number): /*elided*/ any;
+        rolling_quantile(quantile: number, windowSize: number): /*elided*/ any;
+        rolling_std(windowSize: number): /*elided*/ any;
+        rolling_sum(windowSize: number): /*elided*/ any;
+        ops: import("../../types").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        aggFn?: import("../../types").AggFn<any> | null;
+        groupingOpsIndex?: number;
+        partitionOpsIndex?: number;
+        partitionBy?: (string | IExpr)[] | null;
+        windowOp?: {
+            type: string;
+            [key: string]: any;
+        } | null;
+        isWindow?: boolean;
+        alias(name: string): /*elided*/ any;
+        cast(dataType: import("../../types").RegisteredDataType): /*elided*/ any;
+        _resolve(val: any, columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData | any;
+        evaluate(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
+        evaluatePreGrouping(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
+        evaluatePostGrouping(aggregatedArray: any[], columns: import("../../types").ColumnDict): import("../../types").ColumnData;
+        evaluatePrePartition(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
+        evaluatePostPartition(aggregatedArray: any[], columns: import("../../types").ColumnDict): import("../../types").ColumnData;
+        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
+        debug(label?: string): /*elided*/ any;
+        _window(evaluateWindow: (this: IExpr, groupPreValues: any[], partitionIndices: number[], currentIndex: number) => any): /*elided*/ any;
+        _rolling(windowSize: number, aggFn: (vals: any[]) => any): /*elided*/ any;
+        _deriveAgg(fn: import("../../types").AggFn<any>): /*elided*/ any;
+    };
+} & TBase;

package/dist/columnExpressions/mixins/NumericExpr.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumericExpr = void 0;
+const ExprBase_1 = require("../ExprBase");
+const utils_1 = require("../../utils");
+const exceptions_1 = require("../../exceptions");
+const NumericExpr = (Base) => {
+    return class extends Base {
+        abs() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => Math.abs(v)));
+        }
+        acos() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => (v < -1 || v > 1) ? null : Math.acos(v)));
+        }
+        acosh() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => v < 1 ? null : Math.acosh(v)));
+        }
+        add(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => v + r));
+        }
+        asin() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => (v < -1 || v > 1) ? null : Math.asin(v)));
+        }
+        asinh() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.asinh));
+        }
+        atan() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.atan));
+        }
+        atanh() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => (v <= -1 || v >= 1) ? null : Math.atanh(v)));
+        }
+        cbrt() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.cbrt));
+        }
+        ceil() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.ceil));
+        }
+        clip(lower = null, upper = null) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => {
+                if (lower !== null && upper !== null) {
+                    return (0, utils_1.clamp)(v, lower, upper);
+                }
+                else if (lower !== null) {
+                    return Math.max(v, lower);
+                }
+                else if (upper !== null) {
+                    return Math.min(v, upper);
+                }
+                return v;
+            }));
+        }
+        cos() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.cos));
+        }
+        cosh() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.cosh));
+        }
+        degrees() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => v * (180 / Math.PI)));
+        }
+        div(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => r === 0 ? null : v / r));
+        }
+        exp() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.exp));
+        }
+        expm1() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.expm1));
+        }
+        floor() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.floor));
+        }
+        floordiv(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => r === 0 ? null : Math.floor(v / r)));
+        }
+        hypot(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => Math.hypot(v, r)));
+        }
+        log(base = Math.E) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => v <= 0 ? null : (base === Math.E ? Math.log(v) : Math.log(v) / Math.log(base))));
+        }
+        log1p() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => v <= -1 ? null : Math.log1p(v)));
+        }
+        mod(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => r === 0 ? null : v % r));
+        }
+        mul(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => v * r));
+        }
+        negate() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => -v));
+        }
+        pow(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => Math.pow(v, r)));
+        }
+        radians() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => v * (Math.PI / 180)));
+        }
+        rand(seed, { min = 0, max = 1, integer = false } = {}) {
+            return (0, ExprBase_1.derive)(this, (vArray) => {
+                const len = vArray.length;
+                const out = new Float64Array(len);
+                const rnd = seed !== undefined ? (0, utils_1.mulberry32)(seed) : Math.random;
+                const range = max - min;
+                for (let i = 0; i < len; i++) {
+                    const raw = rnd();
+                    out[i] = integer ? Math.floor(raw * (range + 1)) + min : raw * range + min;
+                }
+                return out;
+            });
+        }
+        round(decimals = 0) {
+            const factor = Math.pow(10, decimals);
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => Math.round(v * factor) / factor));
+        }
+        sign() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.sign));
+        }
+        sin() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.sin));
+        }
+        sinh() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.sinh));
+        }
+        sqrt() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => v < 0 ? null : Math.sqrt(v)));
+        }
+        sub(val) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, val, (v, r) => v - r));
+        }
+        tan() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.tan));
+        }
+        tanh() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.tanh));
+        }
+        trunc() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)(Math.trunc));
+        }
+        // Numeric Aggregations
+        avg() {
+            return this._deriveAgg((v) => (0, utils_1.getListStats)(v).mean);
+        }
+        mean() {
+            return this.avg();
+        }
+        sum() {
+            return this._deriveAgg((v) => (0, utils_1.getListStats)(v).sum);
+        }
+        std() {
+            return this._deriveAgg((v) => (0, utils_1.getListStats)(v).std);
+        }
+        min() {
+            return this._deriveAgg((v) => (0, utils_1.getListStats)(v).min);
+        }
+        max() {
+            return this._deriveAgg((v) => (0, utils_1.getListStats)(v).max);
+        }
+        median() {
+            return this._deriveAgg((v) => (0, utils_1.computeMedian)(v));
+        }
+        quantile(q) {
+            if (q < 0 || q > 1)
+                throw new exceptions_1.ComputeError("Quantile q must be between 0 and 1");
+            return this._deriveAgg((v) => (0, utils_1.computeQuantile)(v, q));
+        }
+        count(options = {}) {
+            if (options.includeNulls)
+                return this._deriveAgg((v) => v.length);
+            return this._deriveAgg((v) => (0, utils_1.getListStats)(v).count);
+        }
+        // Numeric Cumulative/Rolling Windows
+        cum_max(reverse = false) {
+            return this._window(function (groupPreValues, _partitionIndices, currentIndex) {
+                let maxVal = null;
+                const start = reverse ? currentIndex : 0;
+                const end = reverse ? groupPreValues.length - 1 : currentIndex;
+                for (let i = start; i <= end; i++) {
+                    const val = groupPreValues[i];
+                    if (val != null) {
+                        if (maxVal === null || val > maxVal) {
+                            maxVal = val;
+                        }
+                    }
+                }
+                return maxVal;
+            });
+        }
+        cum_min(reverse = false) {
+            return this._window(function (groupPreValues, _partitionIndices, currentIndex) {
+                let minVal = null;
+                const start = reverse ? currentIndex : 0;
+                const end = reverse ? groupPreValues.length - 1 : currentIndex;
+                for (let i = start; i <= end; i++) {
+                    const val = groupPreValues[i];
+                    if (val != null) {
+                        if (minVal === null || val < minVal) {
+                            minVal = val;
+                        }
+                    }
+                }
+                return minVal;
+            });
+        }
+        cum_prod(reverse = false) {
+            return this._window(function (groupPreValues, _partitionIndices, currentIndex) {
+                let prod = 1;
+                let hasValid = false;
+                const start = reverse ? currentIndex : 0;
+                const end = reverse ? groupPreValues.length - 1 : currentIndex;
+                for (let i = start; i <= end; i++) {
+                    const val = groupPreValues[i];
+                    if (val != null) {
+                        prod *= val;
+                        hasValid = true;
+                    }
+                }
+                return hasValid ? prod : null;
+            });
+        }
+        cum_sum(reverse = false) {
+            return this._window(function (groupPreValues, _partitionIndices, currentIndex) {
+                let sum = 0;
+                const start = reverse ? currentIndex : 0;
+                const end = reverse ? groupPreValues.length - 1 : currentIndex;
+                for (let i = start; i <= end; i++) {
+                    const val = groupPreValues[i];
+                    if (val != null)
+                        sum += val;
+                }
+                return sum;
+            });
+        }
+        rolling_max(windowSize) {
+            return this._rolling(windowSize, (v) => (0, utils_1.getListStats)(v).max);
+        }
+        rolling_mean(windowSize) {
+            return this._rolling(windowSize, (v) => (0, utils_1.getListStats)(v).mean);
+        }
+        rolling_median(windowSize) {
+            return this._rolling(windowSize, (v) => (0, utils_1.computeMedian)(v));
+        }
+        rolling_min(windowSize) {
+            return this._rolling(windowSize, (v) => (0, utils_1.getListStats)(v).min);
+        }
+        rolling_quantile(quantile, windowSize) {
+            return this._rolling(windowSize, (v) => (0, utils_1.computeQuantile)(v, quantile));
+        }
+        rolling_std(windowSize) {
+            return this._rolling(windowSize, (v) => (0, utils_1.getListStats)(v).std);
+        }
+        rolling_sum(windowSize) {
+            return this._rolling(windowSize, (v) => (0, utils_1.getListStats)(v).sum);
+        }
+    };
+};
+exports.NumericExpr = NumericExpr;

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

@@ -1,10 +1,11 @@
 import type { IExpr } from "../../types";
-import type { ExprConstructor } from "../types";
+import { ExprBase } from "../ExprBase";
 import { StripCharsOptions } from "../../utils";
 export declare class StringExprNamespace {
     expr: any;
     constructor(expr: any);
     _deriveString(fn: (v: string) => any): any;
+    _patternGuard(pattern: any, fn: () => any): any;
     concat(other: string | IExpr): any;
     contains(pattern: string | RegExp): any;
     count_matches(pattern: string | RegExp): any;
@@ -48,32 +49,6 @@ export declare class StringExprNamespace {
     upper(): any;
     zfill(width: number): any;
 }
-export declare const StringExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    new (...args: any[]): {
-        get str(): StringExprNamespace;
-        ops: import("../../types").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("../../types").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | 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("../../types").ColumnDict, height: number): import("../../types").ColumnData | any;
-        evaluate(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
-        evaluatePreGrouping(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("../../types").ColumnDict): import("../../types").ColumnData;
-        evaluatePrePartition(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("../../types").ColumnDict): import("../../types").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & TBase;
+export declare class StringExpr extends ExprBase {
+    get str(): StringExprNamespace;
+}