@thi.ng/tensors 0.1.0

package/subn.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Componentwise nD tensor subtraction with uniform scalar `n`. Writes result to
+ * `out`. If `out` is null, mutates `a`. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const subN: import("./api.js").MultiTensorOpTN<number>;
+/**
+ * Same as {@link subN} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const subN1: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link subN} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const subN2: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link subN} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const subN3: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link subN} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ * @param n - scalar
+ */
+export declare const subN4: import("./api.js").TensorOpTN<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=subn.d.ts.map

package/subn.js

@@ -0,0 +1,15 @@
+import { $sub } from "@thi.ng/vectors/ops";
+import { defOpTN } from "./defoptn.js";
+const [a, b, c, d, e] = defOpTN($sub);
+const subN = a;
+const subN1 = b;
+const subN2 = c;
+const subN3 = d;
+const subN4 = e;
+export {
+  subN,
+  subN1,
+  subN2,
+  subN3,
+  subN4
+};

package/sum.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Componentwise sum of given nD tensor. Multi-method.
+ *
+ * @param a - input tensor
+ */
+export declare const sum: import("./api.js").MultiTensorOpRT<number, number>;
+/**
+ * Componentwise sum of given 1D tensor.
+ *
+ * @param a - input tensor
+ */
+export declare const sum1: import("./api.js").TensorOpRT<number, number, import("./tensor.js").Tensor1<number>>;
+/**
+ * Componentwise sum of given 2D tensor.
+ *
+ * @param a - input tensor
+ */
+export declare const sum2: import("./api.js").TensorOpRT<number, number, import("./tensor.js").Tensor2<number>>;
+/**
+ * Componentwise sum of given 3D tensor.
+ *
+ * @param a - input tensor
+ */
+export declare const sum3: import("./api.js").TensorOpRT<number, number, import("./tensor.js").Tensor3<number>>;
+/**
+ * Componentwise sum of given 4D tensor.
+ *
+ * @param a - input tensor
+ */
+export declare const sum4: import("./api.js").TensorOpRT<number, number, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=sum.d.ts.map

package/sum.js

@@ -0,0 +1,15 @@
+import { $add } from "@thi.ng/vectors/ops";
+import { defOpRT } from "./defoprt.js";
+const [a, b, c, d, e] = defOpRT($add, () => 0);
+const sum = a;
+const sum1 = b;
+const sum2 = c;
+const sum3 = d;
+const sum4 = e;
+export {
+  sum,
+  sum1,
+  sum2,
+  sum3,
+  sum4
+};

package/tan.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Componentwise computes `Math.tan` of given nD tensor and writes result to
+ * `out`. If `out` is null, mutates original. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const tan: import("./api.js").MultiTensorOpT<number>;
+/**
+ * Same as {@link tan} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const tan1: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link tan} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const tan2: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link tan} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const tan3: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link tan} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const tan4: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=tan.d.ts.map

package/tan.js

@@ -0,0 +1,14 @@
+import { defOpT } from "./defopt.js";
+const [a, b, c, d, e] = defOpT(Math.tan);
+const tan = a;
+const tan1 = b;
+const tan2 = c;
+const tan3 = d;
+const tan4 = e;
+export {
+  tan,
+  tan1,
+  tan2,
+  tan3,
+  tan4
+};

package/tanh.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Componentwise computes `Math.tanh` of given nD tensor and writes result to
+ * `out`. If `out` is null, mutates original. Multi-method.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const tanh: import("./api.js").MultiTensorOpT<number>;
+/**
+ * Same as {@link tanh} for 1D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const tanh1: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor1<number>, import("./tensor.js").Tensor1<number>>;
+/**
+ * Same as {@link tanh} for 2D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const tanh2: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor2<number>, import("./tensor.js").Tensor2<number>>;
+/**
+ * Same as {@link tanh} for 3D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const tanh3: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor3<number>, import("./tensor.js").Tensor3<number>>;
+/**
+ * Same as {@link tanh} for 4D tensors.
+ *
+ * @param out - output tensor
+ * @param a - input tensor
+ */
+export declare const tanh4: import("./api.js").TensorOpT<number, number, import("./tensor.js").Tensor4<number>, import("./tensor.js").Tensor4<number>>;
+//# sourceMappingURL=tanh.d.ts.map

package/tanh.js

@@ -0,0 +1,14 @@
+import { defOpT } from "./defopt.js";
+const [a, b, c, d, e] = defOpT(Math.tanh);
+const tanh = a;
+const tanh1 = b;
+const tanh2 = c;
+const tanh3 = d;
+const tanh4 = e;
+export {
+  tanh,
+  tanh1,
+  tanh2,
+  tanh3,
+  tanh4
+};

package/tensor.d.ts

@@ -0,0 +1,127 @@
+import type { Maybe, 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>;
+    copy(): typeof this;
+    empty(storage?: ITensorStorage<T>): typeof this;
+    equiv(o: any): boolean;
+    eqDelta(o: ITensor<T>, eps?: number): boolean;
+    abstract index(pos: NumericArray): number;
+    abstract get(pos: NumericArray): T;
+    abstract set(pos: NumericArray, v: T): this;
+    hi(pos: NumericArray): this;
+    lo(pos: 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: any[];
+    };
+}
+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;
+    get([x]: NumericArray): T;
+    set([x]: NumericArray, v: T): this;
+    pick([x]: NumericArray): Tensor1<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: Maybe<TensorCtor<any>>[];
+/** 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]>;
+/**
+ * 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 shapeToStride: (shape: NumericArray) => any[];
+export declare const strideOrder: (strides: number[]) => number[];
+//# sourceMappingURL=tensor.d.ts.map