/**
 * Aggregate a vector using one or more aggregators. Like a multi-purpose reducer.
 * @param v - Numerivcal vector
 * @param aggregater - A single or multiple aggregator
 *   functions. The aggregator functions work like reducers.
 * @param startValue - A single or multiple start values
 * @param options.getter - A value getter
 * @return A single or multiple aggregagted values
 */
export declare const aggregate: (v: number[], aggregater: ((acc: number, val: number) => number) | ((acc: number, val: number) => number)[], startValue: number | number[], { getter }?: {
    getter?: (<T>(x: T) => T) | undefined;
}) => number | number[];
/**
 * Get the difference of two vectoe
 * @param v - Numerical vectors
 * @param w - Numerical vectors
 * @return Difference vector
 */
export declare const diff: (v: number[], w: number[]) => number[];
/**
 * L distance between a pair of vectors
 *
 * @param l - Defines the Lp space
 * @param dim - Dimension of the input data (Optional)
 * @returns A function to calculate the `l` distance between
 *   a pair of vectors.
 */
export declare const lDist: (l: number, dim: number) => ((v: number[], w: number[]) => number | undefined);
/**
 * L1 distance between a pair of vectors
 *
 * @description This is identical but much faster than `lDist(1)(v, w)`
 * @param v - First vector
 * @param w - Second vector
 * @return L2 distance
 */
export declare const l1Dist: (v: number[], w: number[]) => number | undefined;
/**
 * Creates a l1 distance function tailored to the dimension of the data
 *
 * @description This is identical but faster than `l1Dist(v, w)`.
 * @param dim - Dimension of the input data
 * @return A function with the same signature as `l1Dist`
 */
export declare const l1DistByDim: (dim: number) => ((v: number[], w: number[]) => number);
/**
 * L2 distance between a pair of vectors
 *
 * @description This is identical but much faster than `lDist(2)(v, w)`.
 * @param v - First vector
 * @param w - Second vector
 * @return L2 distance
 */
export declare const l2Dist: (v: number[], w: number[]) => number | undefined;
/**
 * Creates a l2 distance function tailored to the dimension of the data
 *
 * @description
 * This is identical but faster than `l2Dist(v, w)`
 *
 * @param dim - Dimension of the input data
 * @return A function with the same signature as `l2Dist`
 */
export declare const l2DistByDim: (dim: number) => ((v: number[], w: number[]) => number);
/**
 * Vector L2 norm
 *
 * @description
 * This is identical but much faster than `Math.hypot(...v)`
 *
 * @param v - Numerical vector
 * @return L2 norm
 */
export declare const l2Norm: (v: number[]) => number;
/**
 * Get the maximum number of a vector while ignoring NaNs
 *
 * @description
 * This version is muuuch faster than `Math.max(...v)` and supports vectors
 * longer than 256^2, which is a limitation of `Math.max.apply(null, v)`.
 *
 * @param v - Numerical vector
 * @return The largest number
 */
export declare const max: (v: number[]) => number;
export declare const maxNan: (v: number[]) => number;
/**
 * Get the max vector
 * @param m - Array of vectors
 * @return Max vector
 */
export declare const maxVector: (m: number[][]) => number[];
/**
 * Get the mean of a vector
 *
 * @param v - Numerical vector
 * @return The mean
 */
export declare const mean: (v: number[]) => number;
/**
 * Get the mean of a vector while ignoring NaNs
 *
 * @description Roughly 30% slower than `mean()`
 * @param v - Numerical vector
 * @return The mean
 */
export declare const meanNan: (v: number[]) => number;
/**
 * Get the mean vector
 * @param m - Array of vectors
 * @return Mean vector
 */
export declare const meanVector: (m: number[][]) => number[];
/**
 * Get the median of a vector
 *
 * @param v - Numerical vector
 * @return The median
 */
export declare const median: (v: number[]) => number;
/**
 * Get the median vector
 * @param m - Array of vectors
 * @return The median vector
 */
export declare const medianVector: (v: number[]) => number;
/**
 * Get the minimum number of a vector while ignoring NaNs
 *
 * @description
 * This version is muuuch faster than `Math.min(...v)` and supports vectors
 * longer than 256^2, which is a limitation of `Math.min.apply(null, v)`.
 *
 * @param v - Numerical vector
 * @return The smallest number
 */
export declare const min: (v: number[]) => number;
export declare const minNan: (v: number[]) => number;
/**
 * Get the min vector
 * @param m - Array of vectors
 * @return Min vector
 */
export declare const minVector: (m: number[][]) => number[];
/**
 * Non-negative modulo function. E.g., `mod(-1, 5) === 4` while `-1 % 5 === -1`.
 *
 * @param x - Dividend
 * @param y - Divisor
 * @return Remainder
 */
export declare const mod: (x: number, y: number) => number;
/**
 * Normalize vector
 * @param v - Numerical vector
 * @return Unit vector
 */
export declare const normalize: (v: number[]) => number[];
/**
 * Initialize an array of a certain length using a mapping function
 *
 * @description
 * This is equivalent to `Array.from({ length }, mapFn)` but about 60% faster
 *
 * @param length - Size of the array
 * @param mapFn - Mapping function
 * @return Initialized array
 */
export declare const rangeMap: (length: number, mapFn?: (i: number, length: number) => number) => number[];
/**
 * A function to created a range array
 * @param start - Start of the range (included)
 * @param end - End of the range (excluded)
 * @param stepSize - Increase per step
 * @return Range array
 */
export declare const range: (start: number, end: number, stepSize?: number) => number[];
/**
 * Get the sum of a vector while ignoring NaNs
 *
 * @example
 * sum([0, 10, 12, 22])
 * // >> 42
 *
 * @param values - Numerical vector
 * @return The sum
 */
export declare const sum: (values: number[]) => number;
export declare const sumNan: (values: number[]) => number;
/**
 * Get the sum vector
 * @param m - Array of vectors
 * @return Sum vector
 */
export declare const sumVector: (m: number[][]) => number[];
/**
 * Get the unique union of two vectors of integers
 * @param v - First vector of integers
 * @param w - Second vector of integers
 * @return Unique union of `v` and `w`
 */
export declare const unionIntegers: (v: number[], w: number[]) => number[];