@ai-on-browser/data-analysis-models
Version:
Data analysis model package without any dependencies
322 lines (321 loc) • 11 kB
TypeScript
/**
* @template {number} T
* @typedef {Array<T | NestedArray<T>>} NestedArray
*/
/**
* Tensor class
* @template {*} [T=number] - Element type
*/
export default class Tensor<T extends unknown = number> {
/**
* Returns a tensor filled with 0.
* @overload
* @param {...number} size Sizes for each dimension
* @returns {Tensor<number>} Tensor filled with 0
*/
static zeros(...size: number[]): Tensor<number>;
/**
* Returns a tensor filled with 0.
* @overload
* @param {number[]} size Sizes for each dimension
* @returns {Tensor<number>} Tensor filled with 0
*/
static zeros(size: number[]): Tensor<number>;
/**
* Returns a tensor filled with 1.
* @overload
* @param {...number} size Sizes for each dimension
* @returns {Tensor<number>} Tensor filled with 1
*/
static ones(...size: number[]): Tensor<number>;
/**
* Returns a tensor filled with 1.
* @overload
* @param {number[]} size Sizes for each dimension
* @returns {Tensor<number>} Tensor filled with 1
*/
static ones(size: number[]): Tensor<number>;
/**
* Returns a tensor initialized uniform random values.
* @param {number[]} size Sizes for each dimension
* @param {number} [min] Minimum value of the Tensor
* @param {number} [max] Maximum value of the Tensor
* @returns {Tensor<number>} Tensor initialized uniform random values
*/
static random(size: number[], min?: number, max?: number): Tensor<number>;
/**
* Returns a tensor initialized normal random values.
* @param {number[]} size Sizes for each dimension
* @param {number} [myu] Mean value of the Tensor
* @param {number} [sigma] Variance value of the Tensor
* @returns {Tensor<number>} Tensor initialized normal random values
*/
static randn(size: number[], myu?: number, sigma?: number): Tensor<number>;
/**
* Returns a tensor from some value.
* @template T
* @param {Tensor<T> | Matrix<T> | NestedArray<T> | T} arr Original values
* @returns {Tensor<T>} Tensor from some value
*/
static fromArray<T_1>(arr: Tensor<T_1> | Matrix<T_1> | NestedArray<T_1> | T_1): Tensor<T_1>;
/**
* @param {number[]} size Sizes for each dimension
* @param {T | NestedArray<T>} [value] Initial values
*/
constructor(size: number[], value?: T | NestedArray<T>);
/** @private */
private _size;
/** @private */
private _length;
/** @private */
private _value;
/** @private */
private _offset;
/**
* Dimension of the tensor.
* @type {number}
*/
get dimension(): number;
/**
* Sizes of the tensor.
* @type {number[]}
*/
get sizes(): number[];
/**
* Number of all elements in the tensor.
* @type {number}
*/
get length(): number;
/**
* Elements in the tensor.
* @type {T[]}
*/
get value(): T[];
/**
* Returns a nested array represented this tensor.
* @returns {NestedArray<T>} Nested array
*/
toArray(): NestedArray<T>;
/**
* Returns a string represented this tensor.
* @returns {string} String represented this tensor
*/
toString(): string;
/**
* Returns a Matrix if the dimension of this tensor is 2.
* @returns {Matrix<T>} Matrix
* @throws {MatrixException} If the dimension of this tensor is not 2.
*/
toMatrix(): Matrix<T>;
/**
* Returns the only element.
* @returns {T} The only element
*/
toScaler(): T;
_to_position(...i: any[]): number;
_to_index(p: any): any[];
/**
* Returns a copy of this tensor.
* @returns {Tensor<T>} Copied tensor
*/
copy(): Tensor<T>;
/**
* Returns this tensor is equals to the others.
* @param {*} other Check tensor
* @returns {boolean} `true` if equal
*/
equals(other: any): boolean;
/**
* Returns value at the index position.
* @overload
* @param {...number} i Index values
* @returns {T} The value
*/
at(...i: number[]): T;
/**
* Returns value at the index position.
* @overload
* @param {number[]} i Index values
* @returns {T} The value
*/
at(i: number[]): T;
/**
* Returns tensor at the index position.
* @overload
* @param {...number} i Index values
* @returns {Tensor<T>} Sub tensor
*/
index(...i: number[]): Tensor<T>;
/**
* Returns tensor at the index position.
* @overload
* @param {number[]} i Index values
* @returns {Tensor<T>} Sub tensor
*/
index(i: number[]): Tensor<T>;
/**
* Set the value at the specific position.
* @param {number | number[]} i Index values
* @param {T} value Set value
*/
set(i: number | number[], value: T): void;
/**
* Returns the sub-tensor corresponding to position i in the first dimension of this.
* @param {number | number[]} idx Select index value(s)
* @param {number} [axis] Axis
* @returns {Tensor<T>} Selected tensor
*/
select(idx: number | number[], axis?: number): Tensor<T>;
/**
* Returns a tensor sliced by first dimension.
* @param {number} from Start index
* @param {number} to End index
* @param {number} [axis] Axis
* @returns {Tensor<T>} Sliced tensor
*/
slice(from: number, to: number, axis?: number): Tensor<T>;
/**
* Fill in all the elements with the value.
* @param {T} value Filled value
*/
fill(value: T): void;
/**
* Iterate over all the elements and replace the value.
* @param {function (T, number[], Tensor<T>): T} cb Mapping function
*/
map(cb: (arg0: T, arg1: number[], arg2: Tensor<T>) => T): void;
/**
* Iterate over all the elements.
* @param {function (T, number[], Tensor<T>): void} cb Callback function
*/
forEach(cb: (arg0: T, arg1: number[], arg2: Tensor<T>) => void): void;
/**
* Returns a tensor transposed along the axis.
* @param {...number} axises Selected axises
* @returns {Tensor<T>} Transposed tensor
*/
/**
* Returns a tensor transposed along the axis.
* @param {number[]} axises Selected axises
* @returns {Tensor<T>} Transposed tensor
*/
/**
* @param {...number | number[]} axises Selected axises
* @returns {Tensor<T>} Transposed tensor
*/
transpose(...axises: (number | number[])[]): Tensor<T>;
/**
* Flip values along the axis.
* @param {number} [axis] Axis to be flipped
*/
flip(axis?: number): void;
/**
* Shuffle along the axis.
* @param {number} [axis] Axis
*/
shuffle(axis?: number): void;
/**
* Resize this tensor.
* @param {number[]} sizes New sizes
* @param {number} [init] Value of the extended region
*/
resize(sizes: number[], init?: number): void;
/**
* Reshape this as the sizes.
* @overload
* @param {...number} sizes New sizes for each dimension
*/
reshape(...sizes: number[]): any;
/**
* Reshape this as the sizes.
* @overload
* @param {number[]} sizes New sizes for each dimension
*/
reshape(sizes: number[]): any;
/**
* Repeat the elements n times along the axis this.
* @overload
* @param {number} n Repeated count
* @param {number} [axis] Axis to be repeated
*/
repeat(n: number, axis?: number): any;
/**
* Repeat the elements n times along the axis this.
* @overload
* @param {number[]} n Repeated counts of each axis
*/
repeat(n: number[]): any;
/**
* Concatenate this and t.
* @param {Tensor<T>} t Concatenate tensor
* @param {number} [axis] Axis to be concatenated
*/
concat(t: Tensor<T>, axis?: number): void;
/**
* Returns a tensor reduced along all element with the callback function.
* @overload
* @param {function (T, T, number[], Tensor<T>): T} cb Reducing function
* @param {undefined | null} [init] Initial value
* @returns {T} Reduced tensor or value
*/
reduce(cb: (arg0: T, arg1: T, arg2: number[], arg3: Tensor<T>) => T, init?: undefined | null): T;
/**
* Returns a tensor reduced along all element with the callback function.
* @template U
* @overload
* @param {function (U, T, number[], Tensor<T>): U} cb Reducing function
* @param {U} init Initial value
* @returns {U} Reduced tensor or value
*/
reduce<U>(cb: (arg0: U, arg1: T, arg2: number[], arg3: Tensor<T>) => U, init: U): U;
/**
* Returns a tensor reduced along the axis with the callback function.
* @template {boolean} F
* @overload
* @param {function (T, T, number[], Tensor<T>): T} cb Reducing function
* @param {undefined | null} init Initial value
* @param {number | number[]} axis Axis to be reduced. If negative, reduce along all elements.
* @param {F} [keepdims] Keep dimensions or not.
* @returns {Tensor<T> | (F extends true ? never : T)} Reduced tensor or value
*/
reduce<F extends boolean>(cb: (arg0: T, arg1: T, arg2: number[], arg3: Tensor<T>) => T, init: undefined | null, axis: number | number[], keepdims?: F): Tensor<T> | (F extends true ? never : T);
/**
* Returns a tensor reduced along the axis with the callback function.
* @template U
* @template {boolean} F
* @overload
* @param {function (U, T, number[], Tensor<T>): U} cb Reducing function
* @param {U} init Initial value
* @param {number | number[]} axis Axis to be reduced. If negative, reduce along all elements.
* @param {F} [keepdims] Keep dimensions or not.
* @returns {Tensor<U> | (F extends true ? never : U)} Reduced tensor or value
*/
reduce<U, F extends boolean>(cb: (arg0: U, arg1: T, arg2: number[], arg3: Tensor<T>) => U, init: U, axis: number | number[], keepdims?: F): Tensor<U> | (F extends true ? never : U);
/**
* Apply function for all elements with broadcasting.
* @template U
* @param {Tensor<U> | Matrix<U> | U} o Applied value
* @param {function (T, U): T} fn Applied function
*/
broadcastOperate<U>(o: Tensor<U> | Matrix<U> | U, fn: (arg0: T, arg1: U) => T): void;
/**
* Apply function to the position.
* @param {number | number[]} i Index values
* @param {function (T): T} [fn] Applied function
* @returns {T} Old value
*/
operateAt(i: number | number[], fn?: (arg0: T) => T): T;
/**
* Returns a tensor product value.
* @param {Matrix<number>} o Right matrix
* @returns {Tensor<number>} Producted tensor
*/
dot(o: Matrix<number>): Tensor<number>;
/**
* Iterate over the elements.
* @yields {T}
*/
[Symbol.iterator](): Generator<any, void, unknown>;
}
export type NestedArray<T extends number> = Array<T | NestedArray<T>>;
import Matrix from './matrix.js';