@thi.ng/tensors/tensor.d.ts

0D/1D/2D/3D/4D tensors with extensible polymorphic operations and customizable storage

import type { NumericArray } from "@thi.ng/api";
import type { ITensor, ITensorStorage, Nested, NestedTensor, NumType, Shape, ShapeTensor, TensorCtor, TensorData, TensorFromArrayOpts, TensorOpts, Type, TypeMap } from "./api.js";
export declare abstract class ATensor<T = number> implements ITensor<T> {
    type: Type;
    storage: ITensorStorage<T>;
    data: TensorData<T>;
    shape: number[];
    stride: number[];
    offset: number;
    constructor(type: Type, storage: ITensorStorage<T>, data: TensorData<T>, shape: number[], stride: number[], offset?: number);
    abstract get dim(): number;
    abstract get length(): number;
    get order(): number[];
    get orderedShape(): number[];
    get orderedStride(): number[];
    abstract [Symbol.iterator](): IterableIterator<T>;
    broadcast<S extends Shape>(shape: S, stride: S): ShapeTensor<S, T>;
    copy(): typeof this;
    empty(storage?: ITensorStorage<T>): typeof this;
    /**
     * Calls {@link ITensorStorage.release} with this tensor's data.
     */
    release(): boolean;
    equiv(o: any): boolean;
    eqDelta(o: ITensor<T>, eps?: number): boolean;
    abstract index(pos: NumericArray): number;
    position(index: number): number[];
    abstract get(pos: NumericArray): T;
    abstract set(pos: NumericArray, v: T): this;
    hi(pos: NumericArray): this;
    lo(pos: NumericArray): this;
    crop(pos: NumericArray, size: NumericArray): this;
    step(select: NumericArray): typeof this;
    pick(select: NumericArray): ITensor<T>;
    pack(storage?: ITensorStorage<T>): typeof this;
    reshape<S extends Shape>(newShape: S, newStride?: S): ShapeTensor<S, T>;
    abstract resize<S extends Shape>(newShape: S, fill?: T, storage?: ITensorStorage<T>): ShapeTensor<S, T>;
    transpose(order: NumericArray): typeof this;
    abstract toString(): string;
    toJSON(): {
        buf: T[];
        shape: number[];
        stride: number[];
    };
}
export declare class Tensor0<T = number> extends ATensor<T> {
    [Symbol.iterator](): IterableIterator<T>;
    get dim(): number;
    get order(): number[];
    get length(): number;
    index(): number;
    position(): number[];
    get(): T;
    set(_: NumericArray, v: T): this;
    pick([x]: NumericArray): Tensor0<T>;
    resize<S extends Shape>(newShape: S, fill?: T, storage?: ITensorStorage<T>): ShapeTensor<S, T>;
    transpose(_: number[]): this;
    toString(): string;
}
export declare class Tensor1<T = number> extends ATensor<T> {
    [Symbol.iterator](): IterableIterator<T>;
    get dim(): number;
    get order(): number[];
    get length(): number;
    index([x]: NumericArray): number;
    position(index: number): number[];
    get([x]: NumericArray): T;
    set([x]: NumericArray, v: T): this;
    pick([x]: NumericArray): ITensor<T>;
    resize<S extends Shape>(newShape: S, fill?: T, storage?: ITensorStorage<T>): ShapeTensor<S, T>;
    transpose(_: number[]): this;
    toString(): string;
}
export declare class Tensor2<T = number> extends ATensor<T> {
    protected _n: number;
    [Symbol.iterator](): Generator<T, void, unknown>;
    get length(): number;
    get dim(): number;
    get order(): number[];
    index(pos: NumericArray): number;
    get(pos: NumericArray): T;
    set(pos: NumericArray, v: T): this;
    resize<S extends Shape>(newShape: S, fill?: T, storage?: ITensorStorage<T>): ShapeTensor<S, T>;
    toString(): string;
}
export declare class Tensor3<T = number> extends ATensor<T> {
    protected _n: number;
    [Symbol.iterator](): Generator<T, void, unknown>;
    get length(): number;
    get dim(): number;
    index(pos: NumericArray): number;
    get(pos: NumericArray): T;
    set(pos: NumericArray, v: T): this;
    resize<S extends Shape>(newShape: S, fill?: T, storage?: ITensorStorage<T>): ShapeTensor<S, T>;
    toString(): string;
}
export declare class Tensor4<T = number> extends ATensor<T> {
    protected _n: number;
    [Symbol.iterator](): Generator<T, void, unknown>;
    get length(): number;
    get dim(): number;
    index(pos: NumericArray): number;
    get(pos: NumericArray): T;
    set(pos: NumericArray, v: T): this;
    resize<S extends Shape>(newShape: S, fill?: T, storage?: ITensorStorage<T>): ShapeTensor<S, T>;
    toString(): string;
}
export declare const TENSOR_IMPLS: TensorCtor<any>[];
/** Syntax sugar for wrapping a single scalar value */
export declare function tensor(value: number): Tensor0<number>;
export declare function tensor(value: string): Tensor0<string>;
/** Syntax sugar for {@link tensorFromArray}. */
export declare function tensor<T extends NumType, N extends Nested<number>>(data: N, opts?: TensorFromArrayOpts<T, number>): NestedTensor<N, number>;
/** Syntax sugar for {@link tensorFromArray}. */
export declare function tensor<N extends Nested<string>>(data: N, opts?: TensorFromArrayOpts<"str", string>): NestedTensor<N, string>;
/**
 * Creates a new {@link ITensor} instance for given data type, shape and
 * options.
 *
 * @remarks
 * Currently only 1D - 4D tensors are supported.
 *
 * @param type
 * @param shape
 * @param opts
 */
export declare function tensor<T extends Type, S extends Shape>(type: T, shape: S, opts?: TensorOpts<TypeMap[T], S>): ShapeTensor<S, TypeMap[T]>;
/**
 * Returns a matching tensor impl for given shape. If `shape=[1]` the function
 * returns {@link Tensor0}. Returns undefined if no matching impl is available.
 *
 * @param shape
 */
export declare const tensorImpl: (shape: number[]) => TensorCtor<any>;
/**
 * Creates a new {@link ITensor} instance from given (possibly nested) numeric
 * array, and options.
 *
 * @remarks
 * Currently only 1D - 4D tensors are supported.
 *
 * @param data
 * @param opts
 */
export declare function tensorFromArray<T extends NumType, N extends Nested<number>>(data: N, opts?: TensorFromArrayOpts<T, number>): NestedTensor<N, number>;
/**
 * Creates a new {@link ITensor} instance from given (possibly nested) string
 * array, and options.
 *
 * @remarks
 * Currently only 1D - 4D tensors are supported.
 *
 * @param data
 * @param opts
 */
export declare function tensorFromArray<N extends Nested<string>>(data: N, opts?: TensorFromArrayOpts<"str", string>): NestedTensor<N, string>;
export declare const zeroes: <S extends Shape>(shape: S, type?: NumType, storage?: ITensorStorage<number>) => ShapeTensor<S, number>;
export declare const ones: <S extends Shape>(shape: S, type?: NumType, storage?: ITensorStorage<number>) => ShapeTensor<S, number>;
export declare const constant: <T extends Type, S extends Shape>(shape: S, value: TypeMap[T], type: T, storage?: ITensorStorage<TypeMap[T]>) => ShapeTensor<S, TypeMap[T]>;
export declare const shapeToStride: (shape: number[]) => number[];
export declare const strideOrder: (strides: number[]) => number[];
export declare const computeOffset: (shape: number[], stride: number[]) => number;
//# sourceMappingURL=tensor.d.ts.map