catniff 0.1.5 → 0.1.7

package/dist/autograd.d.ts

@@ -6,14 +6,46 @@ export declare enum OP {
     MUL = 3,
     POW = 4,
     DIV = 5,
-    NEG = 6,
-    EXP = 7,
-    LOG = 8,
-    RELU = 9,
-    SIGMOID = 10,
-    TANH = 11,
-    T = 12,
-    MM = 13
+    GE = 6,
+    LE = 7,
+    GT = 8,
+    LT = 9,
+    EQ = 10,
+    LOGICALAND = 11,
+    LOGICALOR = 12,
+    LOGICALXOR = 13,
+    LOGICALNOT = 14,
+    BITWISEAND = 15,
+    BITWISEOR = 16,
+    BITWISEXOR = 17,
+    BITWISENOT = 18,
+    BITWISELEFTSHIFT = 19,
+    BITWISERIGHTSHIFT = 20,
+    NEG = 21,
+    ABS = 22,
+    SIGN = 23,
+    SIN = 24,
+    COS = 25,
+    TAN = 26,
+    ASIN = 27,
+    ACOS = 28,
+    ATAN = 29,
+    SINH = 30,
+    COSH = 31,
+    ASINH = 32,
+    ACOSH = 33,
+    ATANH = 34,
+    SQRT = 35,
+    EXP = 36,
+    LOG = 37,
+    LOG2 = 38,
+    LOG10 = 39,
+    LOG1P = 40,
+    RELU = 41,
+    SIGMOID = 42,
+    TANH = 43,
+    T = 44,
+    MM = 45
 }
 export declare class Node {
     value: Tensor;
@@ -28,9 +60,41 @@ export declare class Node {
     mul(other: Node | number): Node;
     pow(other: Node | number): Node;
     div(other: Node | number): Node;
+    ge(other: Node | number): Node;
+    le(other: Node | number): Node;
+    gt(other: Node | number): Node;
+    lt(other: Node | number): Node;
+    eq(other: Node | number): Node;
+    logicalAnd(other: Node | number): Node;
+    logicalOr(other: Node | number): Node;
+    logicalXor(other: Node | number): Node;
+    logicalNot(): Node;
+    bitwiseAnd(other: Node | number): Node;
+    bitwiseOr(other: Node | number): Node;
+    bitwiseXor(other: Node | number): Node;
+    bitwiseNot(): Node;
+    bitwiseLeftShift(other: Node | number): Node;
+    bitwiseRightShift(other: Node | number): Node;
     neg(): Node;
+    abs(): Node;
+    sign(): Node;
+    sin(): Node;
+    cos(): Node;
+    tan(): Node;
+    asin(): Node;
+    acos(): Node;
+    atan(): Node;
+    sinh(): Node;
+    cosh(): Node;
+    asinh(): Node;
+    acosh(): Node;
+    atanh(): Node;
+    sqrt(): Node;
     exp(): Node;
     log(): Node;
+    log2(): Node;
+    log10(): Node;
+    log1p(): Node;
     relu(): Node;
     sigmoid(): Node;
     tanh(): Node;

package/dist/autograd.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Node = exports.OP = void 0;
 const tensor_1 = require("./tensor");
-const { add, sub, mul, pow, div, neg, exp, log, relu, sigmoid, tanh, ge, t, mm } = tensor_1.TensorMath;
+const { add, sub, mul, pow, div, gt, lt, ge, le, eq, logicalAnd, logicalOr, logicalXor, logicalNot, bitwiseAnd, bitwiseOr, bitwiseXor, bitwiseNot, bitwiseLeftShift, bitwiseRightShift, neg, abs, sign, sin, cos, tan, asin, acos, atan, sinh, cosh, asinh, acosh, atanh, sqrt, exp, log, log2, log10, log1p, relu, sigmoid, tanh, t, mm } = tensor_1.TensorMath;
 var OP;
 (function (OP) {
     OP[OP["NONE"] = 0] = "NONE";
@@ -11,14 +11,46 @@ var OP;
     OP[OP["MUL"] = 3] = "MUL";
     OP[OP["POW"] = 4] = "POW";
     OP[OP["DIV"] = 5] = "DIV";
-    OP[OP["NEG"] = 6] = "NEG";
-    OP[OP["EXP"] = 7] = "EXP";
-    OP[OP["LOG"] = 8] = "LOG";
-    OP[OP["RELU"] = 9] = "RELU";
-    OP[OP["SIGMOID"] = 10] = "SIGMOID";
-    OP[OP["TANH"] = 11] = "TANH";
-    OP[OP["T"] = 12] = "T";
-    OP[OP["MM"] = 13] = "MM";
+    OP[OP["GE"] = 6] = "GE";
+    OP[OP["LE"] = 7] = "LE";
+    OP[OP["GT"] = 8] = "GT";
+    OP[OP["LT"] = 9] = "LT";
+    OP[OP["EQ"] = 10] = "EQ";
+    OP[OP["LOGICALAND"] = 11] = "LOGICALAND";
+    OP[OP["LOGICALOR"] = 12] = "LOGICALOR";
+    OP[OP["LOGICALXOR"] = 13] = "LOGICALXOR";
+    OP[OP["LOGICALNOT"] = 14] = "LOGICALNOT";
+    OP[OP["BITWISEAND"] = 15] = "BITWISEAND";
+    OP[OP["BITWISEOR"] = 16] = "BITWISEOR";
+    OP[OP["BITWISEXOR"] = 17] = "BITWISEXOR";
+    OP[OP["BITWISENOT"] = 18] = "BITWISENOT";
+    OP[OP["BITWISELEFTSHIFT"] = 19] = "BITWISELEFTSHIFT";
+    OP[OP["BITWISERIGHTSHIFT"] = 20] = "BITWISERIGHTSHIFT";
+    OP[OP["NEG"] = 21] = "NEG";
+    OP[OP["ABS"] = 22] = "ABS";
+    OP[OP["SIGN"] = 23] = "SIGN";
+    OP[OP["SIN"] = 24] = "SIN";
+    OP[OP["COS"] = 25] = "COS";
+    OP[OP["TAN"] = 26] = "TAN";
+    OP[OP["ASIN"] = 27] = "ASIN";
+    OP[OP["ACOS"] = 28] = "ACOS";
+    OP[OP["ATAN"] = 29] = "ATAN";
+    OP[OP["SINH"] = 30] = "SINH";
+    OP[OP["COSH"] = 31] = "COSH";
+    OP[OP["ASINH"] = 32] = "ASINH";
+    OP[OP["ACOSH"] = 33] = "ACOSH";
+    OP[OP["ATANH"] = 34] = "ATANH";
+    OP[OP["SQRT"] = 35] = "SQRT";
+    OP[OP["EXP"] = 36] = "EXP";
+    OP[OP["LOG"] = 37] = "LOG";
+    OP[OP["LOG2"] = 38] = "LOG2";
+    OP[OP["LOG10"] = 39] = "LOG10";
+    OP[OP["LOG1P"] = 40] = "LOG1P";
+    OP[OP["RELU"] = 41] = "RELU";
+    OP[OP["SIGMOID"] = 42] = "SIGMOID";
+    OP[OP["TANH"] = 43] = "TANH";
+    OP[OP["T"] = 44] = "T";
+    OP[OP["MM"] = 45] = "MM";
 })(OP || (exports.OP = OP = {}));
 class Node {
     value;
@@ -96,6 +128,124 @@ class Node {
         };
         return out;
     }
+    ge(other) {
+        other = Node.forceNode(other);
+        const out = new Node(ge(this.value, other.value), [this, other], OP.GE);
+        out.feedBackward = () => {
+            // We consider the derivative of ge to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    le(other) {
+        other = Node.forceNode(other);
+        const out = new Node(le(this.value, other.value), [this, other], OP.LE);
+        out.feedBackward = () => {
+            // We consider the derivative of le to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    gt(other) {
+        other = Node.forceNode(other);
+        const out = new Node(gt(this.value, other.value), [this, other], OP.GT);
+        out.feedBackward = () => {
+            // We consider the derivative of gt to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    lt(other) {
+        other = Node.forceNode(other);
+        const out = new Node(lt(this.value, other.value), [this, other], OP.LT);
+        out.feedBackward = () => {
+            // We consider the derivative of lt to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    eq(other) {
+        other = Node.forceNode(other);
+        const out = new Node(eq(this.value, other.value), [this, other], OP.EQ);
+        out.feedBackward = () => {
+            // We consider the derivative of eq to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    logicalAnd(other) {
+        other = Node.forceNode(other);
+        const out = new Node(logicalAnd(this.value, other.value), [this, other], OP.LOGICALAND);
+        out.feedBackward = () => {
+            // We consider the derivative of this to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    logicalOr(other) {
+        other = Node.forceNode(other);
+        const out = new Node(logicalOr(this.value, other.value), [this, other], OP.LOGICALOR);
+        out.feedBackward = () => {
+            // We consider the derivative of this to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    logicalXor(other) {
+        other = Node.forceNode(other);
+        const out = new Node(logicalXor(this.value, other.value), [this, other], OP.LOGICALXOR);
+        out.feedBackward = () => {
+            // We consider the derivative of this to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    logicalNot() {
+        const out = new Node(logicalNot(this.value), [this], OP.LOGICALNOT);
+        out.feedBackward = () => {
+            // We consider the derivative of this to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    bitwiseAnd(other) {
+        other = Node.forceNode(other);
+        const out = new Node(bitwiseAnd(this.value, other.value), [this, other], OP.BITWISEAND);
+        out.feedBackward = () => {
+            // We consider the derivative of this to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    bitwiseOr(other) {
+        other = Node.forceNode(other);
+        const out = new Node(bitwiseOr(this.value, other.value), [this, other], OP.BITWISEOR);
+        out.feedBackward = () => {
+            // We consider the derivative of this to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    bitwiseXor(other) {
+        other = Node.forceNode(other);
+        const out = new Node(bitwiseXor(this.value, other.value), [this, other], OP.BITWISEXOR);
+        out.feedBackward = () => {
+            // We consider the derivative of this to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    bitwiseNot() {
+        const out = new Node(bitwiseNot(this.value), [this], OP.BITWISENOT);
+        out.feedBackward = () => {
+            // We consider the derivative of this to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    bitwiseLeftShift(other) {
+        other = Node.forceNode(other);
+        const out = new Node(bitwiseLeftShift(this.value, other.value), [this, other], OP.BITWISELEFTSHIFT);
+        out.feedBackward = () => {
+            // We consider the derivative of this to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    bitwiseRightShift(other) {
+        other = Node.forceNode(other);
+        const out = new Node(bitwiseRightShift(this.value, other.value), [this, other], OP.BITWISERIGHTSHIFT);
+        out.feedBackward = () => {
+            // We consider the derivative of this to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
     neg() {
         const out = new Node(neg(this.value), [this], OP.NEG);
         out.feedBackward = () => {
@@ -104,6 +254,119 @@ class Node {
         };
         return out;
     }
+    abs() {
+        const out = new Node(abs(this.value), [this], OP.ABS);
+        out.feedBackward = () => {
+            // |x| d/dx = sign(x)
+            Node.addGrad(this, mul(out.grad, sign(this.value)));
+        };
+        return out;
+    }
+    sign() {
+        const out = new Node(sign(this.value), [this], OP.SIGN);
+        out.feedBackward = () => {
+            // We consider the derivative of sign to be 0, which does not add to current grad, so this function is just empty
+        };
+        return out;
+    }
+    sin() {
+        const out = new Node(sin(this.value), [this], OP.SIN);
+        out.feedBackward = () => {
+            // sinx d/dx = cosx
+            Node.addGrad(this, mul(out.grad, cos(this.value)));
+        };
+        return out;
+    }
+    cos() {
+        const out = new Node(cos(this.value), [this], OP.COS);
+        out.feedBackward = () => {
+            // cosx d/dx = -sinx
+            Node.addGrad(this, mul(out.grad, neg(sin(this.value))));
+        };
+        return out;
+    }
+    tan() {
+        const tanResult = tan(this.value);
+        const out = new Node(tanResult, [this], OP.TAN);
+        out.feedBackward = () => {
+            // tanx d/dx = 1+(tanx)^2
+            Node.addGrad(this, mul(out.grad, add(1, pow(tanResult, 2))));
+        };
+        return out;
+    }
+    asin() {
+        const out = new Node(asin(this.value), [this], OP.ASIN);
+        out.feedBackward = () => {
+            // asinx d/dx = 1/sqrt(1-x^2)
+            Node.addGrad(this, div(out.grad, sqrt(sub(1, pow(this.value, 2)))));
+        };
+        return out;
+    }
+    acos() {
+        const out = new Node(acos(this.value), [this], OP.ACOS);
+        out.feedBackward = () => {
+            // acosx d/dx = -1/sqrt(1-x^2)
+            Node.addGrad(this, neg(div(out.grad, sqrt(sub(1, pow(this.value, 2))))));
+        };
+        return out;
+    }
+    atan() {
+        const out = new Node(atan(this.value), [this], OP.ATAN);
+        out.feedBackward = () => {
+            // atanx d/dx = 1/(1+x^2)
+            Node.addGrad(this, div(out.grad, add(1, pow(this.value, 2))));
+        };
+        return out;
+    }
+    sinh() {
+        const out = new Node(sinh(this.value), [this], OP.SINH);
+        out.feedBackward = () => {
+            // sinhx d/dx = coshx
+            Node.addGrad(this, mul(out.grad, cosh(this.value)));
+        };
+        return out;
+    }
+    cosh() {
+        const out = new Node(cosh(this.value), [this], OP.COSH);
+        out.feedBackward = () => {
+            // coshx d/dx = sinhx
+            Node.addGrad(this, mul(out.grad, sinh(this.value)));
+        };
+        return out;
+    }
+    asinh() {
+        const out = new Node(asinh(this.value), [this], OP.ASINH);
+        out.feedBackward = () => {
+            // asinhx d/dx = 1/sqrt(1+x^2)
+            Node.addGrad(this, div(out.grad, sqrt(add(1, pow(this.value, 2)))));
+        };
+        return out;
+    }
+    acosh() {
+        const out = new Node(acosh(this.value), [this], OP.ACOSH);
+        out.feedBackward = () => {
+            // acosx d/dx = 1/(sqrt(x-1)*sqrt(x+1))
+            Node.addGrad(this, div(out.grad, mul(sqrt(sub(this.value, 1)), sqrt(add(this.value, 1)))));
+        };
+        return out;
+    }
+    atanh() {
+        const out = new Node(atanh(this.value), [this], OP.ATANH);
+        out.feedBackward = () => {
+            // atanx d/dx = 1/(1-x^2)
+            Node.addGrad(this, div(out.grad, sub(1, pow(this.value, 2))));
+        };
+        return out;
+    }
+    sqrt() {
+        const sqrtResult = sqrt(this.value);
+        const out = new Node(sqrtResult, [this], OP.SQRT);
+        out.feedBackward = () => {
+            // sqrt(x) d/dx = 1/(2*sqrt(x))
+            Node.addGrad(this, div(out.grad, mul(2, sqrtResult)));
+        };
+        return out;
+    }
     exp() {
         const expResult = exp(this.value);
         const out = new Node(expResult, [this], OP.EXP);
@@ -121,6 +384,30 @@ class Node {
         };
         return out;
     }
+    log2() {
+        const out = new Node(log2(this.value), [this], OP.LOG2);
+        out.feedBackward = () => {
+            // log2(x) d/dx = 1/(xln2)
+            Node.addGrad(this, div(out.grad, mul(this.value, Math.log(2))));
+        };
+        return out;
+    }
+    log10() {
+        const out = new Node(log10(this.value), [this], OP.LOG10);
+        out.feedBackward = () => {
+            // log2(x) d/dx = 1/(xln10)
+            Node.addGrad(this, div(out.grad, mul(this.value, Math.log(10))));
+        };
+        return out;
+    }
+    log1p() {
+        const out = new Node(log1p(this.value), [this], OP.LOG1P);
+        out.feedBackward = () => {
+            // ln(1+x) d/dx = 1/(1+x)
+            Node.addGrad(this, div(out.grad, add(this.value, 1)));
+        };
+        return out;
+    }
     relu() {
         const out = new Node(relu(this.value), [this], OP.RELU);
         out.feedBackward = () => {

package/dist/tensor.d.ts

@@ -3,6 +3,8 @@ export declare class TensorMath {
     static create(num: number, shape: number[]): Tensor;
     static getShape(tA: Tensor): number[];
     static padShape(tA: Tensor, tB: Tensor): [Tensor[], Tensor[]];
+    static elementWiseAB(tA: Tensor, tB: Tensor, op: (tA: number, tB: number) => number): Tensor;
+    static elementWiseSelf(tA: Tensor, op: (tA: number) => number): Tensor;
     static add(tA: Tensor, tB: Tensor): Tensor;
     static sub(tA: Tensor, tB: Tensor): Tensor;
     static mul(tA: Tensor, tB: Tensor): Tensor;
@@ -13,9 +15,36 @@ export declare class TensorMath {
     static ge(tA: Tensor, tB: Tensor): Tensor;
     static le(tA: Tensor, tB: Tensor): Tensor;
     static eq(tA: Tensor, tB: Tensor): Tensor;
+    static logicalAnd(tA: Tensor, tB: Tensor): Tensor;
+    static logicalOr(tA: Tensor, tB: Tensor): Tensor;
+    static logicalXor(tA: Tensor, tB: Tensor): Tensor;
+    static logicalNot(tA: Tensor): Tensor;
+    static bitwiseAnd(tA: Tensor, tB: Tensor): Tensor;
+    static bitwiseOr(tA: Tensor, tB: Tensor): Tensor;
+    static bitwiseXor(tA: Tensor, tB: Tensor): Tensor;
+    static bitwiseNot(tA: Tensor): Tensor;
+    static bitwiseLeftShift(tA: Tensor, tB: Tensor): Tensor;
+    static bitwiseRightShift(tA: Tensor, tB: Tensor): Tensor;
     static neg(tA: Tensor): Tensor;
+    static abs(tA: Tensor): Tensor;
+    static sign(tA: Tensor): Tensor;
+    static sin(tA: Tensor): Tensor;
+    static cos(tA: Tensor): Tensor;
+    static tan(tA: Tensor): Tensor;
+    static asin(tA: Tensor): Tensor;
+    static acos(tA: Tensor): Tensor;
+    static atan(tA: Tensor): Tensor;
+    static sinh(tA: Tensor): Tensor;
+    static cosh(tA: Tensor): Tensor;
+    static asinh(tA: Tensor): Tensor;
+    static acosh(tA: Tensor): Tensor;
+    static atanh(tA: Tensor): Tensor;
+    static sqrt(tA: Tensor): Tensor;
     static exp(tA: Tensor): Tensor;
     static log(tA: Tensor): Tensor;
+    static log2(tA: Tensor): Tensor;
+    static log10(tA: Tensor): Tensor;
+    static log1p(tA: Tensor): Tensor;
     static relu(tA: Tensor): Tensor;
     static sigmoid(tA: Tensor): Tensor;
     static tanh(tA: Tensor): Tensor;

package/dist/tensor.js

@@ -35,9 +35,9 @@ class TensorMath {
         }
         return [tA, tB];
     }
-    static add(tA, tB) {
+    static elementWiseAB(tA, tB, op) {
         if (typeof tA === "number" && typeof tB === "number") {
-            return tA + tB;
+            return op(tA, tB);
         }
         [tA, tB] = TensorMath.padShape(tA, tB);
         const outLen = Math.max(tA.length, tB.length);
@@ -48,210 +48,146 @@ class TensorMath {
         for (let i = 0; i < outLen; i++) {
             const subA = tA[tA.length === 1 ? 0 : i];
             const subB = tB[tB.length === 1 ? 0 : i];
-            result.push(TensorMath.add(subA, subB));
+            result.push(TensorMath.elementWiseAB(subA, subB, op));
         }
         return result;
     }
-    static sub(tA, tB) {
-        if (typeof tA === "number" && typeof tB === "number") {
-            return tA - tB;
-        }
-        [tA, tB] = TensorMath.padShape(tA, tB);
-        const outLen = Math.max(tA.length, tB.length);
-        if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
-            throw new Error("Inputs are incompatible tensors");
+    static elementWiseSelf(tA, op) {
+        if (typeof tA === "number") {
+            return op(tA);
         }
-        const result = [];
-        for (let i = 0; i < outLen; i++) {
-            const subA = tA[tA.length === 1 ? 0 : i];
-            const subB = tB[tB.length === 1 ? 0 : i];
-            result.push(TensorMath.sub(subA, subB));
+        else {
+            return tA.map(subA => TensorMath.elementWiseSelf(subA, op));
         }
-        return result;
+    }
+    static add(tA, tB) {
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA + tB);
+    }
+    static sub(tA, tB) {
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA - tB);
     }
     static mul(tA, tB) {
-        if (typeof tA === "number" && typeof tB === "number") {
-            return tA * tB;
-        }
-        [tA, tB] = TensorMath.padShape(tA, tB);
-        const outLen = Math.max(tA.length, tB.length);
-        if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
-            throw new Error("Inputs are incompatible tensors");
-        }
-        const result = [];
-        for (let i = 0; i < outLen; i++) {
-            const subA = tA[tA.length === 1 ? 0 : i];
-            const subB = tB[tB.length === 1 ? 0 : i];
-            result.push(TensorMath.mul(subA, subB));
-        }
-        return result;
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA * tB);
     }
     static pow(tA, tB) {
-        if (typeof tA === "number" && typeof tB === "number") {
-            return tA ** tB;
-        }
-        [tA, tB] = TensorMath.padShape(tA, tB);
-        const outLen = Math.max(tA.length, tB.length);
-        if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
-            throw new Error("Inputs are incompatible tensors");
-        }
-        const result = [];
-        for (let i = 0; i < outLen; i++) {
-            const subA = tA[tA.length === 1 ? 0 : i];
-            const subB = tB[tB.length === 1 ? 0 : i];
-            result.push(TensorMath.pow(subA, subB));
-        }
-        return result;
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA ** tB);
     }
     static div(tA, tB) {
-        if (typeof tA === "number" && typeof tB === "number") {
-            return tA / tB;
-        }
-        [tA, tB] = TensorMath.padShape(tA, tB);
-        const outLen = Math.max(tA.length, tB.length);
-        if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
-            throw new Error("Inputs are incompatible tensors");
-        }
-        const result = [];
-        for (let i = 0; i < outLen; i++) {
-            const subA = tA[tA.length === 1 ? 0 : i];
-            const subB = tB[tB.length === 1 ? 0 : i];
-            result.push(TensorMath.div(subA, subB));
-        }
-        return result;
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA / tB);
     }
     static gt(tA, tB) {
-        if (typeof tA === "number" && typeof tB === "number") {
-            return tA > tB ? 1 : 0;
-        }
-        [tA, tB] = TensorMath.padShape(tA, tB);
-        const outLen = Math.max(tA.length, tB.length);
-        if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
-            throw new Error("Inputs are incompatible tensors");
-        }
-        const result = [];
-        for (let i = 0; i < outLen; i++) {
-            const subA = tA[tA.length === 1 ? 0 : i];
-            const subB = tB[tB.length === 1 ? 0 : i];
-            result.push(TensorMath.gt(subA, subB));
-        }
-        return result;
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA > tB ? 1 : 0);
     }
     static lt(tA, tB) {
-        if (typeof tA === "number" && typeof tB === "number") {
-            return tA < tB ? 1 : 0;
-        }
-        [tA, tB] = TensorMath.padShape(tA, tB);
-        const outLen = Math.max(tA.length, tB.length);
-        if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
-            throw new Error("Inputs are incompatible tensors");
-        }
-        const result = [];
-        for (let i = 0; i < outLen; i++) {
-            const subA = tA[tA.length === 1 ? 0 : i];
-            const subB = tB[tB.length === 1 ? 0 : i];
-            result.push(TensorMath.lt(subA, subB));
-        }
-        return result;
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA < tB ? 1 : 0);
     }
     static ge(tA, tB) {
-        if (typeof tA === "number" && typeof tB === "number") {
-            return tA >= tB ? 1 : 0;
-        }
-        [tA, tB] = TensorMath.padShape(tA, tB);
-        const outLen = Math.max(tA.length, tB.length);
-        if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
-            throw new Error("Inputs are incompatible tensors");
-        }
-        const result = [];
-        for (let i = 0; i < outLen; i++) {
-            const subA = tA[tA.length === 1 ? 0 : i];
-            const subB = tB[tB.length === 1 ? 0 : i];
-            result.push(TensorMath.ge(subA, subB));
-        }
-        return result;
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA >= tB ? 1 : 0);
     }
     static le(tA, tB) {
-        if (typeof tA === "number" && typeof tB === "number") {
-            return tA <= tB ? 1 : 0;
-        }
-        [tA, tB] = TensorMath.padShape(tA, tB);
-        const outLen = Math.max(tA.length, tB.length);
-        if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
-            throw new Error("Inputs are incompatible tensors");
-        }
-        const result = [];
-        for (let i = 0; i < outLen; i++) {
-            const subA = tA[tA.length === 1 ? 0 : i];
-            const subB = tB[tB.length === 1 ? 0 : i];
-            result.push(TensorMath.le(subA, subB));
-        }
-        return result;
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA <= tB ? 1 : 0);
     }
     static eq(tA, tB) {
-        if (typeof tA === "number" && typeof tB === "number") {
-            return tA === tB ? 1 : 0;
-        }
-        [tA, tB] = TensorMath.padShape(tA, tB);
-        const outLen = Math.max(tA.length, tB.length);
-        if (tA.length !== tB.length && tA.length !== 1 && tB.length !== 1) {
-            throw new Error("Inputs are incompatible tensors");
-        }
-        const result = [];
-        for (let i = 0; i < outLen; i++) {
-            const subA = tA[tA.length === 1 ? 0 : i];
-            const subB = tB[tB.length === 1 ? 0 : i];
-            result.push(TensorMath.eq(subA, subB));
-        }
-        return result;
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA === tB ? 1 : 0);
+    }
+    static logicalAnd(tA, tB) {
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA === 1 && tB === 1 ? 1 : 0);
+    }
+    static logicalOr(tA, tB) {
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA === 1 || tB === 1 ? 1 : 0);
+    }
+    static logicalXor(tA, tB) {
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => (tA === 1 || tB === 1) && tA !== tB ? 1 : 0);
+    }
+    static logicalNot(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => tA === 1 ? 0 : 1);
+    }
+    static bitwiseAnd(tA, tB) {
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA & tB);
+    }
+    static bitwiseOr(tA, tB) {
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA | tB);
+    }
+    static bitwiseXor(tA, tB) {
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA ^ tB);
+    }
+    static bitwiseNot(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => ~tA);
+    }
+    static bitwiseLeftShift(tA, tB) {
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA << tB);
+    }
+    static bitwiseRightShift(tA, tB) {
+        return TensorMath.elementWiseAB(tA, tB, (tA, tB) => tA >> tB);
     }
     static neg(tA) {
-        if (typeof tA === "number") {
-            return -tA;
-        }
-        else {
-            return tA.map(subA => TensorMath.neg(subA));
-        }
+        return TensorMath.elementWiseSelf(tA, (tA) => -tA);
+    }
+    static abs(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.abs(tA));
+    }
+    static sign(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.sign(tA));
+    }
+    static sin(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.sin(tA));
+    }
+    static cos(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.cos(tA));
+    }
+    static tan(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.tan(tA));
+    }
+    static asin(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.asin(tA));
+    }
+    static acos(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.acos(tA));
+    }
+    static atan(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.atan(tA));
+    }
+    static sinh(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.sinh(tA));
+    }
+    static cosh(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.cosh(tA));
+    }
+    static asinh(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.asinh(tA));
+    }
+    static acosh(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.acosh(tA));
+    }
+    static atanh(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.atanh(tA));
+    }
+    static sqrt(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.sqrt(tA));
     }
     static exp(tA) {
-        if (typeof tA === "number") {
-            return Math.exp(tA);
-        }
-        else {
-            return tA.map(subA => TensorMath.exp(subA));
-        }
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.exp(tA));
     }
     static log(tA) {
-        if (typeof tA === "number") {
-            return Math.log(tA);
-        }
-        else {
-            return tA.map(subA => TensorMath.log(subA));
-        }
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.log(tA));
+    }
+    static log2(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.log2(tA));
+    }
+    static log10(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.log10(tA));
+    }
+    static log1p(tA) {
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.log(tA));
     }
     static relu(tA) {
-        if (typeof tA === "number") {
-            return Math.max(tA, 0);
-        }
-        else {
-            return tA.map(subA => TensorMath.relu(subA));
-        }
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.max(tA, 0));
     }
     static sigmoid(tA) {
-        if (typeof tA === "number") {
-            return 1 / (1 + Math.exp(-tA));
-        }
-        else {
-            return tA.map(subA => TensorMath.sigmoid(subA));
-        }
+        return TensorMath.elementWiseSelf(tA, (tA) => 1 / (1 + Math.exp(-tA)));
     }
     static tanh(tA) {
-        if (typeof tA === "number") {
-            return Math.tanh(tA);
-        }
-        else {
-            return tA.map(subA => TensorMath.tanh(subA));
-        }
+        return TensorMath.elementWiseSelf(tA, (tA) => Math.tanh(tA));
     }
     static squeezeAxis(tA, axis) {
         if (typeof tA === "number")

package/package.json

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