@elaraai/east 1.0.65 → 1.0.67

package/dist/src/expr/vector.d.ts

@@ -3,7 +3,7 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 import type { AST } from "../ast.js";
-import { IntegerType, VectorType, FunctionType, type NeverType } from "../types.js";
+import { BooleanType, FloatType, IntegerType, VectorType, FunctionType, type NeverType } from "../types.js";
 import type { IntegerExpr } from "./integer.js";
 import { Expr, type ToExpr } from "./expr.js";
 import type { SubtypeExprOrValue, ExprType, TypeOf } from "./types.js";
@@ -97,5 +97,221 @@ export declare class VectorExpr<T extends any> extends Expr<VectorType<T>> {
      * @returns The final accumulated value
      */
     reduce<T2>(combineFn: SubtypeExprOrValue<FunctionType<[previous: TypeOf<NoInfer<T2>>, value: T, key: IntegerType], TypeOf<NoInfer<T2>>>>, init: T2): ExprType<TypeOf<T2>>;
+    /** Requires a Float or Integer element type for the arithmetic builtins. */
+    private numericElem;
+    /** Requires a Boolean element type for the mask builtins. */
+    private maskElem;
+    /** Builds a unary/binary elementwise builtin returning a vector of this element type. */
+    private elementwise;
+    /**
+     * Multiplies every element by a scalar, producing a new vector.
+     *
+     * @param alpha - The scalar factor (same type as the elements)
+     * @returns A new VectorExpr with every element scaled by alpha
+     */
+    scale(alpha: SubtypeExprOrValue<T>): VectorExpr<T>;
+    /**
+     * Sums the elements in index order, left to right.
+     *
+     * The accumulation order is part of the cross-runtime contract: a
+     * reassociated float sum gives a different last bit. An empty vector sums
+     * to zero.
+     *
+     * @returns An expression of the element type holding the sum
+     */
+    sum(): ExprType<T>;
+    /**
+     * Adds a scaled vector elementwise: `this + alpha * other`.
+     *
+     * Add and subtract fall out at `alpha` of one and minus one.
+     *
+     * @param other - The vector to scale and add (same length and element type)
+     * @param alpha - The scalar factor applied to other
+     * @returns A new VectorExpr holding the combined elements
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    addScaled(other: SubtypeExprOrValue<VectorType<T>>, alpha: SubtypeExprOrValue<T>): VectorExpr<T>;
+    /**
+     * Multiplies two vectors elementwise.
+     *
+     * @param other - The vector to multiply with (same length and element type)
+     * @returns A new VectorExpr holding the elementwise products
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    mul(other: SubtypeExprOrValue<VectorType<T>>): VectorExpr<T>;
+    /**
+     * Adds a scalar to every element, producing a new vector.
+     *
+     * @param value - The scalar addend (same type as the elements)
+     * @returns A new VectorExpr with value added to every element
+     */
+    addScalar(value: SubtypeExprOrValue<T>): VectorExpr<T>;
+    /**
+     * Computes the dot product, accumulating in index order, left to right.
+     *
+     * @param other - The vector to multiply with (same length and element type)
+     * @returns An expression of the element type holding the dot product
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    dot(other: SubtypeExprOrValue<VectorType<T>>): ExprType<T>;
+    /**
+     * Returns the largest element under East's total order (NaN is greatest).
+     * Ties resolve to the earliest occurrence.
+     *
+     * @returns An expression of the element type holding the maximum
+     *
+     * @throws East runtime error if the vector is empty
+     */
+    max(): ExprType<T>;
+    /**
+     * Returns the smallest element under East's total order.
+     * Ties resolve to the earliest occurrence.
+     *
+     * @returns An expression of the element type holding the minimum
+     *
+     * @throws East runtime error if the vector is empty
+     */
+    min(): ExprType<T>;
+    /**
+     * Returns the index of the largest element under East's total order.
+     * Ties resolve to the earliest occurrence.
+     *
+     * @returns An IntegerExpr holding the index of the maximum
+     *
+     * @throws East runtime error if the vector is empty
+     */
+    argMax(): IntegerExpr;
+    /**
+     * Returns the index of the smallest element under East's total order.
+     * Ties resolve to the earliest occurrence.
+     *
+     * @returns An IntegerExpr holding the index of the minimum
+     *
+     * @throws East runtime error if the vector is empty
+     */
+    argMin(): IntegerExpr;
+    /**
+     * Computes the arithmetic mean as a Float, accumulating in index order.
+     * Integer elements widen to Float per element; an empty vector yields NaN.
+     *
+     * @returns A FloatExpr holding the mean
+     */
+    mean(): ExprType<FloatType>;
+    /**
+     * Computes the running sum in index order, left to right.
+     * Element i of the result is the sum of elements 0 through i.
+     *
+     * @returns A new VectorExpr of the running sums
+     */
+    cumSum(): VectorExpr<T>;
+    /**
+     * Takes the absolute value of every element.
+     *
+     * @returns A new VectorExpr with every element replaced by its magnitude
+     */
+    abs(): VectorExpr<T>;
+    /**
+     * Clamps every element between lo and hi under East's total order:
+     * an element below lo becomes lo, one above hi becomes hi.
+     *
+     * @param lo - The lower bound (same type as the elements)
+     * @param hi - The upper bound (same type as the elements)
+     * @returns A new VectorExpr with every element clamped
+     */
+    clamp(lo: SubtypeExprOrValue<T>, hi: SubtypeExprOrValue<T>): VectorExpr<T>;
+    /**
+     * Gathers elements at the given indices: element j of the result is
+     * `this[indices[j]]`.
+     *
+     * @param indices - The indices to read, as a Vector of Integers
+     * @returns A new VectorExpr with one element per index
+     *
+     * @throws East runtime error if any index is out of bounds
+     */
+    gather(indices: SubtypeExprOrValue<VectorType<IntegerType>>): VectorExpr<T>;
+    /**
+     * Returns a copy of this vector with `src[j]` added at `indices[j]` for
+     * each j in order. Duplicate indices accumulate in input order.
+     *
+     * @param indices - The target index for each source element
+     * @param src - The values to add (same length as indices)
+     * @returns A new VectorExpr with the additions applied
+     *
+     * @throws East runtime error if the index and source lengths differ, or any index is out of bounds
+     */
+    scatterAdd(indices: SubtypeExprOrValue<VectorType<IntegerType>>, src: SubtypeExprOrValue<VectorType<T>>): VectorExpr<T>;
+    /**
+     * Finds, for each needle, the leftmost insertion index that keeps this
+     * (sorted) vector sorted under East's total order — numpy's
+     * `searchsorted` with side "left". Assumes this vector is sorted; the
+     * result is unspecified otherwise.
+     *
+     * @param needles - The values to locate
+     * @returns A VectorExpr of Integers holding one insertion index per needle
+     */
+    searchSorted(needles: SubtypeExprOrValue<VectorType<T>>): VectorExpr<IntegerType>;
+    /** Builds an elementwise comparison builtin returning a Boolean mask. */
+    private comparison;
+    /**
+     * Compares elementwise for equality under East's equality (NaN equals NaN,
+     * negative zero differs from positive zero), producing a Boolean mask.
+     *
+     * @param other - The vector to compare with (same length and element type)
+     * @returns A VectorExpr of Booleans, true where elements are equal
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    eq(other: SubtypeExprOrValue<VectorType<T>>): VectorExpr<BooleanType>;
+    /**
+     * Compares elementwise with less-than under East's total order,
+     * producing a Boolean mask.
+     *
+     * @param other - The vector to compare with (same length and element type)
+     * @returns A VectorExpr of Booleans, true where this element is less
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    lt(other: SubtypeExprOrValue<VectorType<T>>): VectorExpr<BooleanType>;
+    /**
+     * Compares elementwise with greater-than under East's total order,
+     * producing a Boolean mask.
+     *
+     * @param other - The vector to compare with (same length and element type)
+     * @returns A VectorExpr of Booleans, true where this element is greater
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    gt(other: SubtypeExprOrValue<VectorType<T>>): VectorExpr<BooleanType>;
+    /**
+     * Selects elementwise from two vectors using this Boolean vector as the
+     * mask: element i of the result is `a[i]` where this mask is true, else
+     * `b[i]`.
+     *
+     * @param a - The vector supplying elements where the mask is true
+     * @param b - The vector supplying elements where the mask is false
+     * @returns A new VectorExpr of the selected elements
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    select<T2>(a: Expr<VectorType<T2>>, b: SubtypeExprOrValue<VectorType<T2>>): VectorExpr<T2>;
+    /**
+     * Keeps the elements where the mask is true, in order — the dense
+     * analogue of the sparse noise-floor filter.
+     *
+     * @param mask - The Boolean vector deciding which elements survive
+     * @returns A new VectorExpr holding the surviving elements
+     *
+     * @throws East runtime error if the mask and vector lengths differ
+     */
+    compress(mask: SubtypeExprOrValue<VectorType<BooleanType>>): VectorExpr<T>;
+    /**
+     * Counts the true elements of this Boolean vector.
+     *
+     * @returns An IntegerExpr holding the number of true elements
+     */
+    countTrue(): IntegerExpr;
 }
 //# sourceMappingURL=vector.d.ts.map

package/dist/src/expr/vector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/expr/vector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,WAAW,EAAE,UAAU,EAAc,YAAY,EAA4B,KAAK,SAAS,EAAqC,MAAM,aAAa,CAAC;AAE7J,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAa,IAAI,EAA6B,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AACpF,OAAO,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;GAQG;AACH,qBAAa,UAAU,CAAC,CAAC,SAAS,GAAG,CAAE,SAAQ,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IACpD,OAAO,CAAC,YAAY;gBAAZ,YAAY,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM;IAIjE;;;;OAIG;IACH,MAAM,IAAI,WAAW;IAWrB;;;;;;;OAOG;IACH,GAAG,CAAC,KAAK,EAAE,kBAAkB,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;IAYxD;;;;;;;;OAQG;IACH,GAAG,CAAC,KAAK,EAAE,kBAAkB,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAaxF;;;;;;;;OAQG;IACH,KAAK,CAAC,KAAK,EAAE,kBAAkB,CAAC,WAAW,CAAC,EAAE,GAAG,EAAE,kBAAkB,CAAC,WAAW,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAalG;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAWjD;;;;OAIG;IACH,OAAO,IAAI,SAAS,CAAC,CAAC,CAAC;IAWvB;;;;;;;;;OASG;IACH,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,kBAAkB,CAAC,WAAW,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAarG;;;;;OAKG;IACH,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,UAAU,CAAC,EAAE,CAAC;IACrE,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,KAAK,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IAiCxI;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,kBAAkB,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;CAe1K"}
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/expr/vector.ts"],"names":[],"mappings":"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"}

package/dist/src/expr/vector.js

@@ -1,5 +1,6 @@
+import {} from "../builtins.js";
 import { get_location_id } from "../location.js";
-import { IntegerType, VectorType, MatrixType, FunctionType, ArrayType, isSubtype, printType, isTypeEqual } from "../types.js";
+import { BooleanType, FloatType, IntegerType, VectorType, MatrixType, FunctionType, ArrayType, isSubtype, printType, isTypeEqual } from "../types.js";
 import { valueOrExprToAst, valueOrExprToAstTyped } from "./ast.js";
 import { AstSymbol, Expr, FactorySymbol, TypeSymbol } from "./expr.js";
 /**
@@ -198,5 +199,399 @@ export class VectorExpr extends Expr {
             arguments: [this[AstSymbol], initAst, combineAst],
         });
     }
+    /** Requires a Float or Integer element type for the arithmetic builtins. */
+    numericElem(method) {
+        const t = this.element_type;
+        if (t.type !== "Float" && t.type !== "Integer") {
+            throw new Error(`Vector.${method} requires a Float or Integer element type, got ${printType(t)}`);
+        }
+        return t;
+    }
+    /** Requires a Boolean element type for the mask builtins. */
+    maskElem(method) {
+        if (this.element_type.type !== "Boolean") {
+            throw new Error(`Vector.${method} requires a Boolean element type, got ${printType(this.element_type)}`);
+        }
+    }
+    /** Builds a unary/binary elementwise builtin returning a vector of this element type. */
+    elementwise(builtin, args) {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: VectorType(this.element_type),
+            loc_id: get_location_id(),
+            builtin,
+            type_parameters: [this.element_type],
+            arguments: [this[AstSymbol], ...args],
+        });
+    }
+    /**
+     * Multiplies every element by a scalar, producing a new vector.
+     *
+     * @param alpha - The scalar factor (same type as the elements)
+     * @returns A new VectorExpr with every element scaled by alpha
+     */
+    scale(alpha) {
+        const elem = this.numericElem("scale");
+        return this.elementwise("VectorScale", [valueOrExprToAstTyped(alpha, elem)]);
+    }
+    /**
+     * Sums the elements in index order, left to right.
+     *
+     * The accumulation order is part of the cross-runtime contract: a
+     * reassociated float sum gives a different last bit. An empty vector sums
+     * to zero.
+     *
+     * @returns An expression of the element type holding the sum
+     */
+    sum() {
+        const elem = this.numericElem("sum");
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: elem,
+            loc_id: get_location_id(),
+            builtin: "VectorSum",
+            type_parameters: [elem],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Adds a scaled vector elementwise: `this + alpha * other`.
+     *
+     * Add and subtract fall out at `alpha` of one and minus one.
+     *
+     * @param other - The vector to scale and add (same length and element type)
+     * @param alpha - The scalar factor applied to other
+     * @returns A new VectorExpr holding the combined elements
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    addScaled(other, alpha) {
+        const elem = this.numericElem("addScaled");
+        return this.elementwise("VectorAddScaled", [
+            valueOrExprToAstTyped(other, VectorType(elem)),
+            valueOrExprToAstTyped(alpha, elem),
+        ]);
+    }
+    /**
+     * Multiplies two vectors elementwise.
+     *
+     * @param other - The vector to multiply with (same length and element type)
+     * @returns A new VectorExpr holding the elementwise products
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    mul(other) {
+        const elem = this.numericElem("mul");
+        return this.elementwise("VectorMul", [valueOrExprToAstTyped(other, VectorType(elem))]);
+    }
+    /**
+     * Adds a scalar to every element, producing a new vector.
+     *
+     * @param value - The scalar addend (same type as the elements)
+     * @returns A new VectorExpr with value added to every element
+     */
+    addScalar(value) {
+        const elem = this.numericElem("addScalar");
+        return this.elementwise("VectorAddScalar", [valueOrExprToAstTyped(value, elem)]);
+    }
+    /**
+     * Computes the dot product, accumulating in index order, left to right.
+     *
+     * @param other - The vector to multiply with (same length and element type)
+     * @returns An expression of the element type holding the dot product
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    dot(other) {
+        const elem = this.numericElem("dot");
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: elem,
+            loc_id: get_location_id(),
+            builtin: "VectorDot",
+            type_parameters: [elem],
+            arguments: [this[AstSymbol], valueOrExprToAstTyped(other, VectorType(elem))],
+        });
+    }
+    /**
+     * Returns the largest element under East's total order (NaN is greatest).
+     * Ties resolve to the earliest occurrence.
+     *
+     * @returns An expression of the element type holding the maximum
+     *
+     * @throws East runtime error if the vector is empty
+     */
+    max() {
+        const elem = this.numericElem("max");
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: elem,
+            loc_id: get_location_id(),
+            builtin: "VectorMax",
+            type_parameters: [elem],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Returns the smallest element under East's total order.
+     * Ties resolve to the earliest occurrence.
+     *
+     * @returns An expression of the element type holding the minimum
+     *
+     * @throws East runtime error if the vector is empty
+     */
+    min() {
+        const elem = this.numericElem("min");
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: elem,
+            loc_id: get_location_id(),
+            builtin: "VectorMin",
+            type_parameters: [elem],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Returns the index of the largest element under East's total order.
+     * Ties resolve to the earliest occurrence.
+     *
+     * @returns An IntegerExpr holding the index of the maximum
+     *
+     * @throws East runtime error if the vector is empty
+     */
+    argMax() {
+        const elem = this.numericElem("argMax");
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            loc_id: get_location_id(),
+            builtin: "VectorArgMax",
+            type_parameters: [elem],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Returns the index of the smallest element under East's total order.
+     * Ties resolve to the earliest occurrence.
+     *
+     * @returns An IntegerExpr holding the index of the minimum
+     *
+     * @throws East runtime error if the vector is empty
+     */
+    argMin() {
+        const elem = this.numericElem("argMin");
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            loc_id: get_location_id(),
+            builtin: "VectorArgMin",
+            type_parameters: [elem],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Computes the arithmetic mean as a Float, accumulating in index order.
+     * Integer elements widen to Float per element; an empty vector yields NaN.
+     *
+     * @returns A FloatExpr holding the mean
+     */
+    mean() {
+        const elem = this.numericElem("mean");
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: FloatType,
+            loc_id: get_location_id(),
+            builtin: "VectorMean",
+            type_parameters: [elem],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Computes the running sum in index order, left to right.
+     * Element i of the result is the sum of elements 0 through i.
+     *
+     * @returns A new VectorExpr of the running sums
+     */
+    cumSum() {
+        this.numericElem("cumSum");
+        return this.elementwise("VectorCumSum", []);
+    }
+    /**
+     * Takes the absolute value of every element.
+     *
+     * @returns A new VectorExpr with every element replaced by its magnitude
+     */
+    abs() {
+        this.numericElem("abs");
+        return this.elementwise("VectorAbs", []);
+    }
+    /**
+     * Clamps every element between lo and hi under East's total order:
+     * an element below lo becomes lo, one above hi becomes hi.
+     *
+     * @param lo - The lower bound (same type as the elements)
+     * @param hi - The upper bound (same type as the elements)
+     * @returns A new VectorExpr with every element clamped
+     */
+    clamp(lo, hi) {
+        const elem = this.numericElem("clamp");
+        return this.elementwise("VectorClamp", [
+            valueOrExprToAstTyped(lo, elem),
+            valueOrExprToAstTyped(hi, elem),
+        ]);
+    }
+    /**
+     * Gathers elements at the given indices: element j of the result is
+     * `this[indices[j]]`.
+     *
+     * @param indices - The indices to read, as a Vector of Integers
+     * @returns A new VectorExpr with one element per index
+     *
+     * @throws East runtime error if any index is out of bounds
+     */
+    gather(indices) {
+        return this.elementwise("VectorGather", [valueOrExprToAstTyped(indices, VectorType(IntegerType))]);
+    }
+    /**
+     * Returns a copy of this vector with `src[j]` added at `indices[j]` for
+     * each j in order. Duplicate indices accumulate in input order.
+     *
+     * @param indices - The target index for each source element
+     * @param src - The values to add (same length as indices)
+     * @returns A new VectorExpr with the additions applied
+     *
+     * @throws East runtime error if the index and source lengths differ, or any index is out of bounds
+     */
+    scatterAdd(indices, src) {
+        const elem = this.numericElem("scatterAdd");
+        return this.elementwise("VectorScatterAdd", [
+            valueOrExprToAstTyped(indices, VectorType(IntegerType)),
+            valueOrExprToAstTyped(src, VectorType(elem)),
+        ]);
+    }
+    /**
+     * Finds, for each needle, the leftmost insertion index that keeps this
+     * (sorted) vector sorted under East's total order — numpy's
+     * `searchsorted` with side "left". Assumes this vector is sorted; the
+     * result is unspecified otherwise.
+     *
+     * @param needles - The values to locate
+     * @returns A VectorExpr of Integers holding one insertion index per needle
+     */
+    searchSorted(needles) {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: VectorType(IntegerType),
+            loc_id: get_location_id(),
+            builtin: "VectorSearchSorted",
+            type_parameters: [this.element_type],
+            arguments: [this[AstSymbol], valueOrExprToAstTyped(needles, VectorType(this.element_type))],
+        });
+    }
+    /** Builds an elementwise comparison builtin returning a Boolean mask. */
+    comparison(builtin, other) {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: VectorType(BooleanType),
+            loc_id: get_location_id(),
+            builtin,
+            type_parameters: [this.element_type],
+            arguments: [this[AstSymbol], valueOrExprToAstTyped(other, VectorType(this.element_type))],
+        });
+    }
+    /**
+     * Compares elementwise for equality under East's equality (NaN equals NaN,
+     * negative zero differs from positive zero), producing a Boolean mask.
+     *
+     * @param other - The vector to compare with (same length and element type)
+     * @returns A VectorExpr of Booleans, true where elements are equal
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    eq(other) {
+        return this.comparison("VectorEq", other);
+    }
+    /**
+     * Compares elementwise with less-than under East's total order,
+     * producing a Boolean mask.
+     *
+     * @param other - The vector to compare with (same length and element type)
+     * @returns A VectorExpr of Booleans, true where this element is less
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    lt(other) {
+        return this.comparison("VectorLt", other);
+    }
+    /**
+     * Compares elementwise with greater-than under East's total order,
+     * producing a Boolean mask.
+     *
+     * @param other - The vector to compare with (same length and element type)
+     * @returns A VectorExpr of Booleans, true where this element is greater
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    gt(other) {
+        return this.comparison("VectorGt", other);
+    }
+    /**
+     * Selects elementwise from two vectors using this Boolean vector as the
+     * mask: element i of the result is `a[i]` where this mask is true, else
+     * `b[i]`.
+     *
+     * @param a - The vector supplying elements where the mask is true
+     * @param b - The vector supplying elements where the mask is false
+     * @returns A new VectorExpr of the selected elements
+     *
+     * @throws East runtime error if the vector lengths differ
+     */
+    select(a, b) {
+        this.maskElem("select");
+        const elem = Expr.type(a).element;
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: VectorType(elem),
+            loc_id: get_location_id(),
+            builtin: "VectorSelect",
+            type_parameters: [elem],
+            arguments: [this[AstSymbol], Expr.ast(a), valueOrExprToAstTyped(b, VectorType(elem))],
+        });
+    }
+    /**
+     * Keeps the elements where the mask is true, in order — the dense
+     * analogue of the sparse noise-floor filter.
+     *
+     * @param mask - The Boolean vector deciding which elements survive
+     * @returns A new VectorExpr holding the surviving elements
+     *
+     * @throws East runtime error if the mask and vector lengths differ
+     */
+    compress(mask) {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: VectorType(this.element_type),
+            loc_id: get_location_id(),
+            builtin: "VectorCompress",
+            type_parameters: [this.element_type],
+            arguments: [valueOrExprToAstTyped(mask, VectorType(BooleanType)), this[AstSymbol]],
+        });
+    }
+    /**
+     * Counts the true elements of this Boolean vector.
+     *
+     * @returns An IntegerExpr holding the number of true elements
+     */
+    countTrue() {
+        this.maskElem("countTrue");
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            loc_id: get_location_id(),
+            builtin: "VectorCountTrue",
+            type_parameters: [],
+            arguments: [this[AstSymbol]],
+        });
+    }
 }
 //# sourceMappingURL=vector.js.map