df-script 1.4.0

package/dist/columnExpressions/functions/lit.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lit = lit;
+const ColumnExpr_1 = require("../ColumnExpr");
+const constants_1 = require("../constants");
+/**
+ * Creates a literal column expression that repeats the given value for all rows.
+ */
+function lit(value) {
+    const expr = new ColumnExpr_1.ColumnExpr(constants_1.LITERAL_MARKER);
+    expr.isLiteral = true;
+    expr.literalValue = value;
+    expr.ops.push((vArray) => {
+        const height = vArray.length;
+        const result = new Array(height);
+        for (let i = 0; i < height; i++) {
+            result[i] = value;
+        }
+        return result;
+    });
+    return expr;
+}

package/dist/columnExpressions/functions/when.d.ts

@@ -0,0 +1,24 @@
+import { ColumnExpr } from "../ColumnExpr";
+import type { IExpr, Scalar } from "../../types";
+type WhenArg = IExpr | Scalar;
+export declare class WhenThenChain {
+    private predicates;
+    private values;
+    constructor(predicates: WhenArg[], values: WhenArg[]);
+    then(value: WhenArg): WhenThen;
+}
+export declare class When {
+    private predicates;
+    constructor(predicate: WhenArg);
+    then(value: WhenArg): WhenThen;
+}
+export declare class WhenThen extends ColumnExpr<any> {
+    private predicates;
+    private values;
+    private otherwiseValue;
+    constructor(predicates: WhenArg[] | string, values?: WhenArg[], otherwiseValue?: WhenArg);
+    when(predicate: WhenArg): WhenThenChain;
+    otherwise(value: WhenArg): ColumnExpr<any>;
+}
+export declare function when(predicate: WhenArg): When;
+export {};

package/dist/columnExpressions/functions/when.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhenThen = exports.When = exports.WhenThenChain = void 0;
+exports.when = when;
+const ColumnExpr_1 = require("../ColumnExpr");
+const utils_1 = require("../../utils");
+class WhenThenChain {
+    predicates;
+    values;
+    constructor(predicates, values) {
+        this.predicates = predicates;
+        this.values = values;
+    }
+    then(value) {
+        return new WhenThen(this.predicates, this.values.concat(value));
+    }
+}
+exports.WhenThenChain = WhenThenChain;
+class When {
+    predicates;
+    constructor(predicate) {
+        this.predicates = [predicate];
+    }
+    then(value) {
+        return new WhenThen(this.predicates, [value]);
+    }
+}
+exports.When = When;
+class WhenThen extends ColumnExpr_1.ColumnExpr {
+    predicates;
+    values;
+    otherwiseValue;
+    constructor(predicates, values, otherwiseValue = null) {
+        super(typeof predicates === "string" ? predicates : "*when*");
+        this.predicates = Array.isArray(predicates) ? predicates : [];
+        this.values = values || [];
+        this.otherwiseValue = otherwiseValue;
+        this.ops.push((_, columns) => {
+            const height = _.length;
+            const evaluateArg = (arg) => {
+                if (arg && typeof arg === "object" && "evaluate" in arg) {
+                    return arg.evaluate(columns, height);
+                }
+                if (typeof arg === "string" && (arg in columns)) {
+                    return columns[arg];
+                }
+                return arg;
+            };
+            const evaluatedPreds = this.predicates.map(evaluateArg);
+            const evaluatedVals = this.values.map(evaluateArg);
+            const evaluatedOtherwise = evaluateArg(this.otherwiseValue);
+            const result = new Array(height);
+            const numConditions = evaluatedPreds.length;
+            for (let i = 0; i < height; i++) {
+                let matched = false;
+                for (let j = 0; j < numConditions; j++) {
+                    const predVal = (0, utils_1.isArrayOrTypedArray)(evaluatedPreds[j]) ? evaluatedPreds[j][i] : evaluatedPreds[j];
+                    if (predVal === true) {
+                        result[i] = (0, utils_1.isArrayOrTypedArray)(evaluatedVals[j]) ? evaluatedVals[j][i] : evaluatedVals[j];
+                        matched = true;
+                        break;
+                    }
+                }
+                if (!matched) {
+                    result[i] = (0, utils_1.isArrayOrTypedArray)(evaluatedOtherwise) ? evaluatedOtherwise[i] : evaluatedOtherwise;
+                }
+            }
+            return result;
+        });
+    }
+    when(predicate) {
+        return new WhenThenChain(this.predicates.concat(predicate), this.values);
+    }
+    otherwise(value) {
+        return new WhenThen(this.predicates, this.values, value);
+    }
+}
+exports.WhenThen = WhenThen;
+function when(predicate) {
+    return new When(predicate);
+}

package/dist/columnExpressions/index.d.ts

@@ -0,0 +1,19 @@
+import type { IExpr } from "../types";
+export * from "./constants";
+export * from "./types";
+export * from "./ExprBase";
+export * from "./mixins/ArithmeticExpr";
+export * from "./mixins/LogicalExpr";
+export * from "./mixins/ComparisonExpr";
+export * from "./mixins/StringExpr";
+export * from "./mixins/AggregationExpr";
+export * from "./mixins/WindowExpr";
+export * from "./mixins/TemporalExpr";
+export * from "./mixins/ListExpr";
+export * from "./ColumnExpr";
+export * from "./functions/lit";
+export * from "./functions/all";
+export * from "./functions/exclude";
+export * from "./functions/coalesce";
+export * from "./functions/when";
+export declare function resolveColumnSelectors(exprs: any[], allKeys: string[], keysToExcludeFromAll?: string[]): IExpr[];

package/dist/columnExpressions/index.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveColumnSelectors = resolveColumnSelectors;
+const ColumnExpr_1 = require("./ColumnExpr");
+const constants_1 = require("./constants");
+__exportStar(require("./constants"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./ExprBase"), exports);
+__exportStar(require("./mixins/ArithmeticExpr"), exports);
+__exportStar(require("./mixins/LogicalExpr"), exports);
+__exportStar(require("./mixins/ComparisonExpr"), exports);
+__exportStar(require("./mixins/StringExpr"), exports);
+__exportStar(require("./mixins/AggregationExpr"), exports);
+__exportStar(require("./mixins/WindowExpr"), exports);
+__exportStar(require("./mixins/TemporalExpr"), exports);
+__exportStar(require("./mixins/ListExpr"), exports);
+__exportStar(require("./ColumnExpr"), exports);
+__exportStar(require("./functions/lit"), exports);
+__exportStar(require("./functions/all"), exports);
+__exportStar(require("./functions/exclude"), exports);
+__exportStar(require("./functions/coalesce"), exports);
+__exportStar(require("./functions/when"), exports);
+function resolveColumnSelectors(exprs, allKeys, keysToExcludeFromAll) {
+    const expanded = [];
+    const excludeSet = keysToExcludeFromAll ? new Set(keysToExcludeFromAll) : new Set();
+    for (const expr of exprs) {
+        if (typeof expr === "string") {
+            expanded.push(new ColumnExpr_1.ColumnExpr(expr));
+        }
+        else if (expr instanceof ColumnExpr_1.ColumnExpr && expr.colName === constants_1.ALL_COLUMNS_MARKER) {
+            const excluded = new Set(expr.excludedCols);
+            for (const key of allKeys) {
+                if (!excludeSet.has(key) && !excluded.has(key)) {
+                    const concrete = new ColumnExpr_1.ColumnExpr(key);
+                    concrete.ops = [...expr.ops];
+                    concrete.aggFn = expr.aggFn;
+                    concrete.partitionOpsIndex = expr.partitionOpsIndex;
+                    concrete.groupingOpsIndex = expr.groupingOpsIndex;
+                    concrete.partitionBy = expr.partitionBy;
+                    if (expr.evaluateWindow) {
+                        concrete.evaluateWindow = expr.evaluateWindow;
+                    }
+                    if (expr.outputName && expr.outputName !== constants_1.ALL_COLUMNS_MARKER) {
+                        concrete.outputName = expr.outputName;
+                    }
+                    expanded.push(concrete);
+                }
+            }
+        }
+        else if (expr && typeof expr === 'object' && 'evaluate' in expr && !expr.colName) {
+            for (const key of allKeys) {
+                if (!excludeSet.has(key)) {
+                    const concrete = new ColumnExpr_1.ColumnExpr(key);
+                    concrete.ops = [...expr.ops];
+                    concrete.aggFn = expr.aggFn;
+                    concrete.groupingOpsIndex = expr.groupingOpsIndex;
+                    concrete.partitionOpsIndex = expr.partitionOpsIndex;
+                    expanded.push(concrete);
+                }
+            }
+        }
+        else {
+            expanded.push(expr);
+        }
+    }
+    return expanded;
+}

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

@@ -0,0 +1,50 @@
+import type { AggFn } from "../../types";
+import type { ExprConstructor } from "../types";
+export declare const AggregationExpr: <TBase extends ExprConstructor>(Base: TBase) => {
+    new (...args: any[]): {
+        aggFn: AggFn<any> | null;
+        _deriveAgg(fn: AggFn<any>): /*elided*/ any;
+        all(): /*elided*/ any;
+        all_null(): /*elided*/ any;
+        any(): /*elided*/ any;
+        any_null(): /*elided*/ any;
+        avg(): /*elided*/ any;
+        count(options?: {
+            includeNulls?: boolean;
+        }): /*elided*/ any;
+        first(): /*elided*/ any;
+        last(): /*elided*/ any;
+        max(): /*elided*/ any;
+        mean(): /*elided*/ any;
+        median(): /*elided*/ any;
+        min(): /*elided*/ any;
+        mode(): /*elided*/ any;
+        n_unique(): /*elided*/ any;
+        quantile(q: number): /*elided*/ any;
+        std(): /*elided*/ any;
+        sum(): /*elided*/ any;
+        ops: import("../../types").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        groupingOpsIndex?: number;
+        partitionOpsIndex?: number;
+        partitionBy?: (string | import("../../types").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;

package/dist/columnExpressions/mixins/AggregationExpr.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregationExpr = void 0;
+const ExprBase_1 = require("../ExprBase");
+const exceptions_1 = require("../../exceptions");
+const utils_1 = require("../../utils");
+const AggregationExpr = (Base) => {
+    return class extends Base {
+        aggFn = this.aggFn || null;
+        _deriveAgg(fn) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.aggFn = fn;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.partitionOpsIndex = this.ops.length;
+            return newInst;
+        }
+        all() {
+            return this._deriveAgg(v => {
+                for (let i = 0; i < v.length; i++) {
+                    if (!v[i])
+                        return false;
+                }
+                return true;
+            });
+        }
+        all_null() {
+            return this._deriveAgg(v => {
+                for (let i = 0; i < v.length; i++) {
+                    if (v[i] != null)
+                        return false;
+                }
+                return true;
+            });
+        }
+        any() {
+            return this._deriveAgg(v => {
+                for (let i = 0; i < v.length; i++) {
+                    if (v[i])
+                        return true;
+                }
+                return false;
+            });
+        }
+        any_null() {
+            return this._deriveAgg(v => {
+                for (let i = 0; i < v.length; i++) {
+                    if (v[i] == null)
+                        return true;
+                }
+                return false;
+            });
+        }
+        avg() {
+            return this._deriveAgg(v => (0, utils_1.getListStats)(v).mean);
+        }
+        count(options = {}) {
+            if (options.includeNulls)
+                return this._deriveAgg(v => v.length);
+            return this._deriveAgg(v => (0, utils_1.getListStats)(v).count);
+        }
+        first() {
+            return this._deriveAgg(v => v[0] ?? null);
+        }
+        last() {
+            return this._deriveAgg(v => v[v.length - 1] ?? null);
+        }
+        max() {
+            return this._deriveAgg(v => (0, utils_1.getListStats)(v).max);
+        }
+        mean() {
+            return this.avg();
+        }
+        median() {
+            return this._deriveAgg(v => {
+                if (!(0, utils_1.isArrayOfType)(v, "number", { allowNulls: true }))
+                    return null;
+                const len = v.length;
+                const nums = [];
+                for (let i = 0; i < len; i++) {
+                    const val = v[i];
+                    if (val != null) {
+                        nums.push(val);
+                    }
+                }
+                const numsLen = nums.length;
+                if (numsLen === 0)
+                    return null;
+                nums.sort((a, b) => a - b);
+                const mid = Math.floor(numsLen / 2);
+                return numsLen % 2 !== 0
+                    ? nums[mid]
+                    : (nums[mid - 1] + nums[mid]) / 2;
+            });
+        }
+        min() {
+            return this._deriveAgg(v => (0, utils_1.getListStats)(v).min);
+        }
+        mode() {
+            return this._deriveAgg(v => {
+                if (!(0, utils_1.isArrayOrTypedArray)(v))
+                    return null;
+                const len = v.length;
+                const counts = new Map();
+                let maxCount = 0;
+                for (let i = 0; i < len; i++) {
+                    const val = v[i];
+                    if (val == null)
+                        continue;
+                    const c = (counts.get(val) ?? 0) + 1;
+                    counts.set(val, c);
+                    if (c > maxCount)
+                        maxCount = c;
+                }
+                if (maxCount === 0)
+                    return null;
+                const modes = [];
+                for (const [val, c] of counts.entries()) {
+                    if (c === maxCount) {
+                        modes.push(val);
+                    }
+                }
+                if (modes.length === 0)
+                    return null;
+                modes.sort((a, b) => {
+                    if (a == null && b == null)
+                        return 0;
+                    if (a == null)
+                        return 1;
+                    if (b == null)
+                        return -1;
+                    if (a < b)
+                        return -1;
+                    if (a > b)
+                        return 1;
+                    return 0;
+                });
+                return modes[0];
+            });
+        }
+        n_unique() {
+            return this._deriveAgg(v => new Set(v).size);
+        }
+        quantile(q) {
+            if (q < 0 || q > 1)
+                throw new exceptions_1.ComputeError("Quantile q must be between 0 and 1");
+            return this._deriveAgg(v => {
+                const f = [];
+                for (let i = 0; i < v.length; i++) {
+                    if (v[i] != null)
+                        f.push(v[i]);
+                }
+                const fLen = f.length;
+                if (!fLen)
+                    return null;
+                f.sort((a, b) => a - b);
+                const idx = (fLen - 1) * q;
+                const low = Math.floor(idx);
+                const high = Math.ceil(idx);
+                if (low === high)
+                    return f[low];
+                return f[low] + (idx - low) * (f[high] - f[low]);
+            });
+        }
+        std() {
+            return this._deriveAgg(v => (0, utils_1.getListStats)(v).std);
+        }
+        sum() {
+            return this._deriveAgg(v => (0, utils_1.getListStats)(v).sum);
+        }
+    };
+};
+exports.AggregationExpr = AggregationExpr;

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

@@ -0,0 +1,67 @@
+import type { IExpr } from "../../types";
+import type { ExprConstructor, RandomOptions } from "../types";
+export declare const ArithmeticExpr: <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;
+        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;

package/dist/columnExpressions/mixins/ArithmeticExpr.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArithmeticExpr = void 0;
+const ExprBase_1 = require("../ExprBase");
+const utils_1 = require("../../utils");
+const ArithmeticExpr = (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)({ val: v, min: lower, max: 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));
+        }
+    };
+};
+exports.ArithmeticExpr = ArithmeticExpr;