/**
 * @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';