catniff 0.2.12 → 0.2.13

package/dist/core.d.ts

@@ -139,9 +139,20 @@ export declare class Tensor {
     mm(other: TensorValue | Tensor): Tensor;
     mv(other: TensorValue | Tensor): Tensor;
     matmul(other: TensorValue | Tensor): Tensor;
+    static full(shape: number[], num: number, options?: TensorOptions): Tensor;
     static fullLike(tensor: Tensor, num: number, options?: TensorOptions): Tensor;
+    static ones(shape?: number[], options?: TensorOptions): Tensor;
     static onesLike(tensor: Tensor, options?: TensorOptions): Tensor;
+    static zeros(shape?: number[], options?: TensorOptions): Tensor;
     static zerosLike(tensor: Tensor, options?: TensorOptions): Tensor;
+    static rand(shape?: number[], options?: TensorOptions): Tensor;
+    static randLike(tensor: Tensor, options?: TensorOptions): Tensor;
+    static randn(shape?: number[], options?: TensorOptions): Tensor;
+    static randnLike(tensor: Tensor, options?: TensorOptions): Tensor;
+    static randint(shape: number[], low: number, high: number, options?: TensorOptions): Tensor;
+    static randintLike(tensor: Tensor, low: number, high: number, options?: TensorOptions): Tensor;
+    static normal(shape: number[], mean: number, stdDev: number, options?: TensorOptions): Tensor;
+    static uniform(shape: number[], low: number, high: number, options?: TensorOptions): Tensor;
     backward(): void;
     val(): TensorValue;
     withGrad(requiresGrad: boolean): Tensor;

package/dist/core.js

@@ -1101,24 +1101,139 @@ class Tensor {
         // Too lazy for batched matmul
         throw new Error(`Shapes [${this.shape}] and [${other.shape}] are not supported`);
     }
+    // Utility to create a new tensor filled with a number
+    static full(shape, num, options = {}) {
+        if (shape.length === 0)
+            return new Tensor(num, options);
+        const outputSize = Tensor.shapeToSize(shape);
+        const outputValue = new Array(outputSize).fill(num);
+        return new Tensor(outputValue, { shape, ...options });
+    }
     // Utility to create a new tensor with shape of another tensor, filled with a number
     static fullLike(tensor, num, options = {}) {
         if (typeof tensor.value === "number")
             return new Tensor(num, options);
         return new Tensor(new Array(tensor.value.length).fill(num), { shape: tensor.shape, strides: tensor.strides, ...options });
     }
+    // Utility to create a new tensor filled with 1
+    static ones(shape, options = {}) {
+        if (typeof shape === "undefined" || shape.length === 0)
+            return new Tensor(1, options);
+        const outputSize = Tensor.shapeToSize(shape);
+        const outputValue = new Array(outputSize).fill(1);
+        return new Tensor(outputValue, { shape, ...options });
+    }
     // Utility to create a new tensor with shape of another tensor, filled with 1
     static onesLike(tensor, options = {}) {
         if (typeof tensor.value === "number")
             return new Tensor(1, options);
         return new Tensor(new Array(tensor.value.length).fill(1), { shape: tensor.shape, strides: tensor.strides, ...options });
     }
+    // Utility to create a new tensor filled with 0
+    static zeros(shape, options = {}) {
+        if (typeof shape === "undefined" || shape.length === 0)
+            return new Tensor(0, options);
+        const outputSize = Tensor.shapeToSize(shape);
+        const outputValue = new Array(outputSize).fill(0);
+        return new Tensor(outputValue, { shape, ...options });
+    }
     // Utility to create a new tensor with shape of another tensor, filled with 0
     static zerosLike(tensor, options = {}) {
         if (typeof tensor.value === "number")
             return new Tensor(0, options);
         return new Tensor(new Array(tensor.value.length).fill(0), { shape: tensor.shape, strides: tensor.strides, ...options });
     }
+    // Utility to create a new tensor filled with a random number with uniform distribution from 0 to 1
+    static rand(shape, options = {}) {
+        if (typeof shape === "undefined" || shape.length === 0)
+            return new Tensor((0, utils_1.randUniform)(), options);
+        const outputSize = Tensor.shapeToSize(shape);
+        const outputValue = new Array(outputSize);
+        for (let index = 0; index < outputValue.length; index++) {
+            outputValue[index] = (0, utils_1.randUniform)();
+        }
+        return new Tensor(outputValue, { shape, ...options });
+    }
+    // Utility to create a new tensor with shape of another tensor, filled with a random number with uniform distribution from 0 to 1
+    static randLike(tensor, options = {}) {
+        if (typeof tensor.value === "number")
+            return new Tensor((0, utils_1.randUniform)(), options);
+        const outputValue = new Array(tensor.value.length);
+        for (let index = 0; index < outputValue.length; index++) {
+            outputValue[index] = (0, utils_1.randUniform)();
+        }
+        return new Tensor(outputValue, {
+            shape: tensor.shape, strides: tensor.strides, ...options
+        });
+    }
+    // Utility to create a new tensor filled with a random number with normal distribution of mean=0 and stddev=1
+    static randn(shape, options = {}) {
+        if (typeof shape === "undefined" || shape.length === 0)
+            return new Tensor((0, utils_1.randNormal)(), options);
+        const outputSize = Tensor.shapeToSize(shape);
+        const outputValue = new Array(outputSize);
+        for (let index = 0; index < outputValue.length; index++) {
+            outputValue[index] = (0, utils_1.randNormal)();
+        }
+        return new Tensor(outputValue, { shape, ...options });
+    }
+    // Utility to create a new tensor with shape of another tensor, filled with a random number with normal distribution of mean=0 and stddev=1
+    static randnLike(tensor, options = {}) {
+        if (typeof tensor.value === "number")
+            return new Tensor((0, utils_1.randNormal)(), options);
+        const outputValue = new Array(tensor.value.length);
+        for (let index = 0; index < outputValue.length; index++) {
+            outputValue[index] = (0, utils_1.randNormal)();
+        }
+        return new Tensor(outputValue, {
+            shape: tensor.shape, strides: tensor.strides, ...options
+        });
+    }
+    // Utility to create a new tensor filled with a random integer between low and high
+    static randint(shape, low, high, options = {}) {
+        if (shape.length === 0)
+            return new Tensor((0, utils_1.randInt)(low, high), options);
+        const outputSize = Tensor.shapeToSize(shape);
+        const outputValue = new Array(outputSize);
+        for (let index = 0; index < outputValue.length; index++) {
+            outputValue[index] = (0, utils_1.randInt)(low, high);
+        }
+        return new Tensor(outputValue, { shape, ...options });
+    }
+    // Utility to create a new tensor with shape of another tensor, filled with a random integer between low and high
+    static randintLike(tensor, low, high, options = {}) {
+        if (typeof tensor.value === "number")
+            return new Tensor((0, utils_1.randInt)(low, high), options);
+        const outputValue = new Array(tensor.value.length);
+        for (let index = 0; index < outputValue.length; index++) {
+            outputValue[index] = (0, utils_1.randInt)(low, high);
+        }
+        return new Tensor(outputValue, {
+            shape: tensor.shape, strides: tensor.strides, ...options
+        });
+    }
+    // Utility to create a new tensor filled with a random number with normal distribution of custom mean and stddev
+    static normal(shape, mean, stdDev, options = {}) {
+        if (shape.length === 0)
+            return new Tensor((0, utils_1.randNormal)(mean, stdDev), options);
+        const outputSize = Tensor.shapeToSize(shape);
+        const outputValue = new Array(outputSize);
+        for (let index = 0; index < outputValue.length; index++) {
+            outputValue[index] = (0, utils_1.randNormal)(mean, stdDev);
+        }
+        return new Tensor(outputValue, { shape, ...options });
+    }
+    // Utility to create a new tensor filled with a random number with uniform distribution from low to high
+    static uniform(shape, low, high, options = {}) {
+        if (shape.length === 0)
+            return new Tensor((0, utils_1.randUniform)(low, high), options);
+        const outputSize = Tensor.shapeToSize(shape);
+        const outputValue = new Array(outputSize);
+        for (let index = 0; index < outputValue.length; index++) {
+            outputValue[index] = (0, utils_1.randUniform)(low, high);
+        }
+        return new Tensor(outputValue, { shape, ...options });
+    }
     // Reverse-mode autodiff call
     backward() {
         // Build topological order

package/dist/utils.d.ts

@@ -1,3 +1,6 @@
 export declare function erf(x: number): number;
 export declare function erfc(x: number): number;
 export declare function erfinv(x: number): number;
+export declare function randUniform(low?: number, high?: number): number;
+export declare function randNormal(mean?: number, stdDev?: number): number;
+export declare function randInt(low: number, high: number): number;

package/dist/utils.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.erf = erf;
 exports.erfc = erfc;
 exports.erfinv = erfinv;
+exports.randUniform = randUniform;
+exports.randNormal = randNormal;
+exports.randInt = randInt;
 // Error function using Abramowitz and Stegun approximation
 function erf(x) {
     const a1 = 0.254829592;
@@ -33,3 +36,15 @@ function erfinv(x) {
     const sign = x >= 0 ? 1 : -1;
     return sign * Math.sqrt(-part1 + Math.sqrt(part1 * part1 - part2));
 }
+function randUniform(low = 0, high = 1) {
+    return Math.random() * (high - low) + low;
+}
+function randNormal(mean = 0, stdDev = 1) {
+    const u = 1 - Math.random();
+    const v = 1 - Math.random();
+    const z = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+    return z * stdDev + mean;
+}
+function randInt(low, high) {
+    return Math.floor(Math.random() * (high - low) + low);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catniff",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "description": "A cute autograd engine for Javascript",
   "main": "index.js",
   "scripts": {