catniff 0.1.6 → 0.1.8

package/dist/autograd.d.ts

@@ -11,31 +11,42 @@ export declare enum OP {
     GT = 8,
     LT = 9,
     EQ = 10,
-    NEG = 11,
-    ABS = 12,
-    SIGN = 13,
-    SIN = 14,
-    COS = 15,
-    TAN = 16,
-    ASIN = 17,
-    ACOS = 18,
-    ATAN = 19,
-    SINH = 20,
-    COSH = 21,
-    ASINH = 22,
-    ACOSH = 23,
-    ATANH = 24,
-    SQRT = 25,
-    EXP = 26,
-    LOG = 27,
-    LOG2 = 28,
-    LOG10 = 29,
-    LOG1P = 30,
-    RELU = 31,
-    SIGMOID = 32,
-    TANH = 33,
-    T = 34,
-    MM = 35
+    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,
+    DOT = 46
 }
 export declare class Node {
     value: Tensor;
@@ -55,6 +66,16 @@ export declare class 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;
@@ -80,6 +101,7 @@ export declare class Node {
     tanh(): Node;
     t(): Node;
     mm(other: Node | number): Node;
+    dot(other: Node | number): Node;
     backward(): void;
     static forceNode(value: Node | number): Node;
     static addGrad(node: Node, accumGrad: Tensor): void;

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, gt, lt, ge, le, eq, 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;
+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, dot } = tensor_1.TensorMath;
 var OP;
 (function (OP) {
     OP[OP["NONE"] = 0] = "NONE";
@@ -16,31 +16,42 @@ var OP;
     OP[OP["GT"] = 8] = "GT";
     OP[OP["LT"] = 9] = "LT";
     OP[OP["EQ"] = 10] = "EQ";
-    OP[OP["NEG"] = 11] = "NEG";
-    OP[OP["ABS"] = 12] = "ABS";
-    OP[OP["SIGN"] = 13] = "SIGN";
-    OP[OP["SIN"] = 14] = "SIN";
-    OP[OP["COS"] = 15] = "COS";
-    OP[OP["TAN"] = 16] = "TAN";
-    OP[OP["ASIN"] = 17] = "ASIN";
-    OP[OP["ACOS"] = 18] = "ACOS";
-    OP[OP["ATAN"] = 19] = "ATAN";
-    OP[OP["SINH"] = 20] = "SINH";
-    OP[OP["COSH"] = 21] = "COSH";
-    OP[OP["ASINH"] = 22] = "ASINH";
-    OP[OP["ACOSH"] = 23] = "ACOSH";
-    OP[OP["ATANH"] = 24] = "ATANH";
-    OP[OP["SQRT"] = 25] = "SQRT";
-    OP[OP["EXP"] = 26] = "EXP";
-    OP[OP["LOG"] = 27] = "LOG";
-    OP[OP["LOG2"] = 28] = "LOG2";
-    OP[OP["LOG10"] = 29] = "LOG10";
-    OP[OP["LOG1P"] = 30] = "LOG1P";
-    OP[OP["RELU"] = 31] = "RELU";
-    OP[OP["SIGMOID"] = 32] = "SIGMOID";
-    OP[OP["TANH"] = 33] = "TANH";
-    OP[OP["T"] = 34] = "T";
-    OP[OP["MM"] = 35] = "MM";
+    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[OP["DOT"] = 46] = "DOT";
 })(OP || (exports.OP = OP = {}));
 class Node {
     value;
@@ -158,6 +169,84 @@ class Node {
         };
         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 = () => {
@@ -359,6 +448,15 @@ class Node {
         };
         return out;
     }
+    dot(other) {
+        other = Node.forceNode(other);
+        const out = new Node(dot(this.value, other.value), [this, other], OP.DOT);
+        out.feedBackward = () => {
+            Node.addGrad(this, mul(out.grad, other.value));
+            Node.addGrad(other, mul(out.grad, this.value));
+        };
+        return out;
+    }
     backward() {
         // Build topological order
         const topo = [];

package/dist/tensor.d.ts

@@ -15,6 +15,16 @@ 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;
@@ -44,4 +54,5 @@ export declare class TensorMath {
     static sum(tA: Tensor, dims?: number[] | number, keepDims?: boolean): Tensor;
     static t(tA: Tensor): Tensor;
     static mm(tA: Tensor, tB: Tensor): Tensor;
+    static dot(tA: Tensor, tB: Tensor): Tensor;
 }

package/dist/tensor.js

@@ -90,6 +90,36 @@ class TensorMath {
     static eq(tA, tB) {
         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) {
         return TensorMath.elementWiseSelf(tA, (tA) => -tA);
     }
@@ -259,5 +289,19 @@ class TensorMath {
         }
         return matC;
     }
+    static dot(tA, tB) {
+        const shapeA = TensorMath.getShape(tA);
+        const shapeB = TensorMath.getShape(tB);
+        if (shapeA.length !== 1 || shapeB.length !== 1 || shapeA[0] !== shapeB[0])
+            throw new Error("Inputs are not 1D tensors");
+        const vectLen = shapeA[0];
+        const vectA = tA;
+        const vectB = tB;
+        let sum = 0;
+        for (let index = 0; index < vectLen; index++) {
+            sum += vectA[index] * vectB[index];
+        }
+        return sum;
+    }
 }
 exports.TensorMath = TensorMath;

package/package.json

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