catniff 0.2.9 → 0.2.11

package/dist/core.d.ts

@@ -43,14 +43,25 @@ export declare class Tensor {
     mean(dims?: number[] | number, keepDims?: boolean): Tensor;
     add(other: TensorValue | Tensor): Tensor;
     sub(other: TensorValue | Tensor): Tensor;
+    subtract: (other: TensorValue | Tensor) => Tensor;
     mul(other: TensorValue | Tensor): Tensor;
+    multiply: (other: TensorValue | Tensor) => Tensor;
     pow(other: TensorValue | Tensor): Tensor;
     div(other: TensorValue | Tensor): Tensor;
+    divide: (other: TensorValue | Tensor) => Tensor;
+    remainder(other: TensorValue | Tensor): Tensor;
     ge(other: TensorValue | Tensor): Tensor;
+    greaterEqual: (other: TensorValue | Tensor) => Tensor;
     le(other: TensorValue | Tensor): Tensor;
+    lessEqual: (other: TensorValue | Tensor) => Tensor;
     gt(other: TensorValue | Tensor): Tensor;
+    greater: (other: TensorValue | Tensor) => Tensor;
     lt(other: TensorValue | Tensor): Tensor;
+    less: (other: TensorValue | Tensor) => Tensor;
     eq(other: TensorValue | Tensor): Tensor;
+    equal: (other: TensorValue | Tensor) => Tensor;
+    ne(other: TensorValue | Tensor): Tensor;
+    notEqual: (other: TensorValue | Tensor) => Tensor;
     logicalAnd(other: TensorValue | Tensor): Tensor;
     logicalOr(other: TensorValue | Tensor): Tensor;
     logicalXor(other: TensorValue | Tensor): Tensor;
@@ -62,21 +73,38 @@ export declare class Tensor {
     bitwiseLeftShift(other: TensorValue | Tensor): Tensor;
     bitwiseRightShift(other: TensorValue | Tensor): Tensor;
     neg(): Tensor;
+    negative: () => Tensor;
+    reciprocal(): Tensor;
+    square(): Tensor;
     abs(): Tensor;
+    absolute: () => Tensor;
     sign(): Tensor;
     sin(): Tensor;
     cos(): Tensor;
     tan(): Tensor;
     asin(): Tensor;
+    arcsin: () => Tensor;
     acos(): Tensor;
+    arccos: () => Tensor;
     atan(): Tensor;
+    arctan: () => Tensor;
+    atan2(other: TensorValue | Tensor): Tensor;
+    arctan2: (other: TensorValue | Tensor) => Tensor;
     sinh(): Tensor;
     cosh(): Tensor;
     asinh(): Tensor;
+    arcsinh: () => Tensor;
     acosh(): Tensor;
+    arccosh: () => Tensor;
     atanh(): Tensor;
+    arctanh: () => Tensor;
+    deg2rad(): Tensor;
+    rad2deg(): Tensor;
     sqrt(): Tensor;
+    rsqrt(): Tensor;
     exp(): Tensor;
+    exp2(): Tensor;
+    expm1(): Tensor;
     log(): Tensor;
     log2(): Tensor;
     log10(): Tensor;
@@ -84,7 +112,26 @@ export declare class Tensor {
     relu(): Tensor;
     sigmoid(): Tensor;
     tanh(): Tensor;
+    softplus(): Tensor;
+    softsign(): Tensor;
+    silu(): Tensor;
+    mish(): Tensor;
+    maximum(other: TensorValue | Tensor): Tensor;
+    minimum(other: TensorValue | Tensor): Tensor;
+    round(): Tensor;
+    floor(): Tensor;
+    ceil(): Tensor;
+    trunc(): Tensor;
+    fix: () => Tensor;
+    frac(): Tensor;
+    clip(min: number, max: number): Tensor;
+    clamp: (min: number, max: number) => Tensor;
+    erf(): Tensor;
+    erfc(): Tensor;
+    erfinv(): Tensor;
     transpose(dim1: number, dim2: number): Tensor;
+    swapaxes: (dim1: number, dim2: number) => Tensor;
+    swapdims: (dim1: number, dim2: number) => Tensor;
     t(): Tensor;
     dot(other: TensorValue | Tensor): Tensor;
     mm(other: TensorValue | Tensor): Tensor;

package/dist/core.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tensor = void 0;
+const utils_1 = require("./utils");
 class Tensor {
     value;
     shape;
@@ -522,38 +523,55 @@ class Tensor {
     sub(other) {
         return this.elementWiseABDAG(other, (a, b) => a - b, (self, other, outGrad) => outGrad, (self, other, outGrad) => outGrad.neg());
     }
+    subtract = this.sub;
     // Tensor element-wise multiplication
     mul(other) {
         return this.elementWiseABDAG(other, (a, b) => a * b, (self, other, outGrad) => outGrad.mul(other), (self, other, outGrad) => outGrad.mul(self));
     }
+    multiply = this.mul;
     // Tensor element-wise power
     pow(other) {
         return this.elementWiseABDAG(other, (a, b) => a ** b, (self, other, outGrad) => outGrad.mul(other.mul(self.pow(other.sub(1)))), (self, other, outGrad) => outGrad.mul(self.pow(other).mul(self.log())));
     }
     // Tensor element-wise division
     div(other) {
-        return this.elementWiseABDAG(other, (a, b) => a / b, (self, other, outGrad) => outGrad.div(other), (self, other, outGrad) => outGrad.mul(self.neg().div(other.pow(2))));
+        return this.elementWiseABDAG(other, (a, b) => a / b, (self, other, outGrad) => outGrad.div(other), (self, other, outGrad) => outGrad.mul(self.neg().div(other.square())));
+    }
+    divide = this.div;
+    // Tensor element-wise modulo
+    remainder(other) {
+        return this.elementWiseABDAG(other, (a, b) => a % b);
     }
     // Tensor element-wise greater or equal comparison
     ge(other) {
         return this.elementWiseABDAG(other, (a, b) => a >= b ? 1 : 0);
     }
+    greaterEqual = this.ge;
     // Tensor element-wise less or equal comparison
     le(other) {
         return this.elementWiseABDAG(other, (a, b) => a <= b ? 1 : 0);
     }
+    lessEqual = this.le;
     // Tensor element-wise greater-than comparison
     gt(other) {
         return this.elementWiseABDAG(other, (a, b) => a > b ? 1 : 0);
     }
+    greater = this.gt;
     // Tensor element-wise less-than comparison
     lt(other) {
         return this.elementWiseABDAG(other, (a, b) => a < b ? 1 : 0);
     }
+    less = this.lt;
     // Tensor element-wise equality comparison
     eq(other) {
         return this.elementWiseABDAG(other, (a, b) => a === b ? 1 : 0);
     }
+    equal = this.eq;
+    // Tensor element-wise not equality comparison
+    ne(other) {
+        return this.elementWiseABDAG(other, (a, b) => a !== b ? 1 : 0);
+    }
+    notEqual = this.ne;
     // Tensor element-wise logical and
     logicalAnd(other) {
         return this.elementWiseABDAG(other, (a, b) => a === 1 && b === 1 ? 1 : 0);
@@ -598,10 +616,20 @@ class Tensor {
     neg() {
         return this.elementWiseSelfDAG((a) => -a, (self, outGrad) => outGrad.mul(-1));
     }
+    negative = this.neg;
+    // Tensor element-wise reciprocal
+    reciprocal() {
+        return this.elementWiseSelfDAG((a) => 1 / a, (self, outGrad) => outGrad.mul(self.pow(-2).neg()));
+    }
+    // Tensor element-wise square
+    square() {
+        return this.elementWiseSelfDAG((a) => a * a, (self, outGrad) => outGrad.mul(self.mul(2)));
+    }
     // Tensor element-wise absolute
     abs() {
         return this.elementWiseSelfDAG((a) => Math.abs(a), (self, outGrad) => outGrad.mul(self.sign()));
     }
+    absolute = this.abs;
     // Tensor element-wise sign function
     sign() {
         return this.elementWiseSelfDAG((a) => Math.sign(a));
@@ -616,20 +644,28 @@ class Tensor {
     }
     // Tensor element-wise tan
     tan() {
-        return this.elementWiseSelfDAG((a) => Math.tan(a), (self, outGrad) => outGrad.mul(self.tan().pow(2).add(1)));
+        return this.elementWiseSelfDAG((a) => Math.tan(a), (self, outGrad) => outGrad.mul(self.tan().square().add(1)));
     }
     // Tensor element-wise asin
     asin() {
-        return this.elementWiseSelfDAG((a) => Math.asin(a), (self, outGrad) => outGrad.div(self.pow(2).neg().add(1).sqrt()));
+        return this.elementWiseSelfDAG((a) => Math.asin(a), (self, outGrad) => outGrad.div(self.square().neg().add(1).sqrt()));
     }
+    arcsin = this.asin;
     // Tensor element-wise acos
     acos() {
-        return this.elementWiseSelfDAG((a) => Math.acos(a), (self, outGrad) => outGrad.div(self.pow(2).neg().add(1).sqrt()).neg());
+        return this.elementWiseSelfDAG((a) => Math.acos(a), (self, outGrad) => outGrad.div(self.square().neg().add(1).sqrt()).neg());
     }
+    arccos = this.acos;
     // Tensor element-wise atan
     atan() {
-        return this.elementWiseSelfDAG((a) => Math.atan(a), (self, outGrad) => outGrad.div(self.pow(2).add(1)));
+        return this.elementWiseSelfDAG((a) => Math.atan(a), (self, outGrad) => outGrad.div(self.square().add(1)));
     }
+    arctan = this.atan;
+    // Tensor element-wise atan2
+    atan2(other) {
+        return this.elementWiseABDAG(other, (a, b) => Math.atan2(a, b), (self, other, outGrad) => outGrad.mul(other.div(self.square().add(other.square()))), (self, other, outGrad) => outGrad.mul(self.neg().div(self.square().add(other.square()))));
+    }
+    arctan2 = this.atan2;
     // Tensor element-wise sinh
     sinh() {
         return this.elementWiseSelfDAG((a) => Math.sinh(a), (self, outGrad) => outGrad.mul(self.cosh()));
@@ -640,24 +676,47 @@ class Tensor {
     }
     // Tensor element-wise asinh
     asinh() {
-        return this.elementWiseSelfDAG((a) => Math.asinh(a), (self, outGrad) => outGrad.div(self.pow(2).add(1).sqrt()));
+        return this.elementWiseSelfDAG((a) => Math.asinh(a), (self, outGrad) => outGrad.div(self.square().add(1).sqrt()));
     }
+    arcsinh = this.asinh;
     // Tensor element-wise acosh
     acosh() {
         return this.elementWiseSelfDAG((a) => Math.acosh(a), (self, outGrad) => outGrad.div(self.add(1).sqrt().mul(self.sub(1).sqrt())));
     }
+    arccosh = this.acosh;
     // Tensor element-wise atanh
     atanh() {
-        return this.elementWiseSelfDAG((a) => Math.atanh(a), (self, outGrad) => outGrad.div(self.pow(2).neg().add(1)));
+        return this.elementWiseSelfDAG((a) => Math.atanh(a), (self, outGrad) => outGrad.div(self.square().neg().add(1)));
+    }
+    arctanh = this.atanh;
+    // Tensor element-wise degree to radian
+    deg2rad() {
+        return this.elementWiseSelfDAG((a) => a * (Math.PI / 180), (self, outGrad) => outGrad.mul(Math.PI / 180));
+    }
+    // Tensor element-wise radian to degree
+    rad2deg() {
+        return this.elementWiseSelfDAG((a) => a / (Math.PI / 180), (self, outGrad) => outGrad.div(Math.PI / 180));
     }
     // Tensor element-wise square root
     sqrt() {
         return this.elementWiseSelfDAG((a) => Math.sqrt(a), (self, outGrad) => outGrad.div(self.sqrt().mul(2)));
     }
+    // Tensor element-wise reciprocal of square root
+    rsqrt() {
+        return this.elementWiseSelfDAG((a) => 1 / Math.sqrt(a), (self, outGrad) => outGrad.mul(self.pow(-1.5).mul(-0.5)));
+    }
     // Tensor element-wise e^x
     exp() {
         return this.elementWiseSelfDAG((a) => Math.exp(a), (self, outGrad) => outGrad.mul(self.exp()));
     }
+    // Tensor element-wise 2^x
+    exp2() {
+        return this.elementWiseSelfDAG((a) => 2 ** a, (self, outGrad) => outGrad.mul(self.exp2().mul(Math.log(2))));
+    }
+    // Tensor element-wise e^x - 1
+    expm1() {
+        return this.elementWiseSelfDAG((a) => Math.expm1(a), (self, outGrad) => outGrad.mul(self.exp()));
+    }
     // Tensor element-wise natural log
     log() {
         return this.elementWiseSelfDAG((a) => Math.log(a), (self, outGrad) => outGrad.div(self));
@@ -676,7 +735,7 @@ class Tensor {
     }
     // Tensor element-wise relu
     relu() {
-        return this.elementWiseSelfDAG((a) => Math.max(a, 0), (self, outGrad) => outGrad.mul(self.ge(0)));
+        return this.elementWiseSelfDAG((a) => Math.max(a, 0), (self, outGrad) => outGrad.mul(self.gt(0)));
     }
     // Tensor element-wise sigmoid
     sigmoid() {
@@ -687,7 +746,77 @@ class Tensor {
     }
     // Tensor element-wise tanh
     tanh() {
-        return this.elementWiseSelfDAG((a) => Math.tanh(a), (self, outGrad) => outGrad.mul(self.tanh().pow(2).neg().add(1)));
+        return this.elementWiseSelfDAG((a) => Math.tanh(a), (self, outGrad) => outGrad.mul(self.tanh().square().neg().add(1)));
+    }
+    // Tensor element-wise softplus
+    softplus() {
+        return this.elementWiseSelfDAG((a) => Math.log1p(Math.exp(a)), (self, outGrad) => outGrad.mul(self.sigmoid()));
+    }
+    // Tensor element-wise softsign
+    softsign() {
+        return this.elementWiseSelfDAG((a) => a / (1 + Math.abs(a)), (self, outGrad) => outGrad.div(self.abs().add(1).square()));
+    }
+    // Tensor element-wise silu (swish)
+    silu() {
+        return this.elementWiseSelfDAG((a) => a / (1 + Math.exp(-a)), (self, outGrad) => {
+            const sig = self.sigmoid();
+            return outGrad.mul(sig.add(self.mul(sig).mul(sig.neg().add(1))));
+        });
+    }
+    // Tensor element-wise mish
+    mish() {
+        return this.elementWiseSelfDAG((a) => a * Math.tanh(Math.log1p(Math.exp(a))), (self, outGrad) => {
+            const tanhSoftPlus = self.exp().add(1).log().tanh();
+            // tanh(softplus(x)) + x * (1 - tanh²(softplus(x))) * sigmoid(x)
+            const derivative = tanhSoftPlus.add(self.mul(tanhSoftPlus.square().neg().add(1)).mul(self.sigmoid()));
+            return outGrad.mul(derivative);
+        });
+    }
+    // Tensor element-wise maximum
+    maximum(other) {
+        return this.elementWiseABDAG(other, (a, b) => Math.max(a, b), (self, other, outGrad) => outGrad.mul(self.gt(other).add(self.eq(other).mul(0.5))), (self, other, outGrad) => outGrad.mul(other.gt(self).add(other.eq(self).mul(0.5))));
+    }
+    // Tensor element-wise minimum
+    minimum(other) {
+        return this.elementWiseABDAG(other, (a, b) => Math.min(a, b), (self, other, outGrad) => outGrad.mul(self.lt(other).add(self.eq(other).mul(0.5))), (self, other, outGrad) => outGrad.mul(other.lt(self).add(other.eq(self).mul(0.5))));
+    }
+    // Tensor element-wise round
+    round() {
+        return this.elementWiseSelfDAG((a) => Math.round(a));
+    }
+    // Tensor element-wise floor
+    floor() {
+        return this.elementWiseSelfDAG((a) => Math.floor(a));
+    }
+    // Tensor element-wise ceil
+    ceil() {
+        return this.elementWiseSelfDAG((a) => Math.ceil(a));
+    }
+    // Tensor element-wise truncation
+    trunc() {
+        return this.elementWiseSelfDAG((a) => Math.trunc(a));
+    }
+    fix = this.trunc;
+    // Tensor element-wise fraction portion
+    frac() {
+        return this.elementWiseSelfDAG((a) => a - Math.floor(a));
+    }
+    // Tensor element-wise clip and clamp
+    clip(min, max) {
+        return this.elementWiseSelfDAG((a) => Math.max(min, Math.min(max, a)), (self, outGrad) => outGrad.mul(self.ge(min).mul(self.le(max))));
+    }
+    clamp = this.clip;
+    // Tensor element-wise error function
+    erf() {
+        return this.elementWiseSelfDAG((a) => (0, utils_1.erf)(a), (self, outGrad) => outGrad.mul(self.square().neg().exp().mul(2 / Math.sqrt(Math.PI))));
+    }
+    // Tensor element-wise complementary error function
+    erfc() {
+        return this.elementWiseSelfDAG((a) => (0, utils_1.erfc)(a), (self, outGrad) => outGrad.mul(self.square().neg().exp().mul(2 / Math.sqrt(Math.PI)).neg()));
+    }
+    // Tensor element-wise inverse error function
+    erfinv() {
+        return this.elementWiseSelfDAG((a) => (0, utils_1.erfinv)(a), (self, outGrad) => outGrad.mul(self.erfinv().square().exp().mul(Math.sqrt(Math.PI) / 2)));
     }
     // Transpose
     transpose(dim1, dim2) {
@@ -716,6 +845,8 @@ class Tensor {
         }
         return out;
     }
+    swapaxes = this.transpose;
+    swapdims = this.transpose;
     // Transpose 2D
     t() {
         // Verify matrix shape

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function erf(x: number): number;
+export declare function erfc(x: number): number;
+export declare function erfinv(x: number): number;

package/dist/utils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erf = erf;
+exports.erfc = erfc;
+exports.erfinv = erfinv;
+// Error function using Abramowitz and Stegun approximation
+function erf(x) {
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const p = 0.3275911;
+    const sign = x >= 0 ? 1 : -1;
+    x = Math.abs(x);
+    // Formula 7.1.26
+    const t = 1.0 / (1.0 + p * x);
+    const y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);
+    return sign * y;
+}
+// Complementary error function
+function erfc(x) {
+    return 1 - erf(x);
+}
+// Inverse error function using Winitzki approximation
+function erfinv(x) {
+    if (Math.abs(x) >= 1)
+        throw new Error("Input must be in range (-1, 1)");
+    const a = 0.147;
+    const ln = Math.log(1 - x * x);
+    const part1 = 2 / (Math.PI * a) + ln / 2;
+    const part2 = ln / a;
+    const sign = x >= 0 ? 1 : -1;
+    return sign * Math.sqrt(-part1 + Math.sqrt(part1 * part1 - part2));
+}

package/package.json

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