catniff 0.1.4 → 0.1.6

package/README.md

@@ -26,7 +26,7 @@ console.log(x.grad); // 5
 
 Tensors in Catniff are either numbers (scalars/0-D tensors) or multidimensional number arrays (n-D tensors).
 
-There is a built-in `TensorMath` class to help with Tensor arithmetic, for example:
+There is a built-in `TensorMath` class to help with tensor arithmetic, for example:
 ```js
 const { TensorMath } = require("catniff");
 
@@ -70,6 +70,8 @@ All available APIs are in `./src/autograd.ts`.
 I'm mostly just learning and playing with this currently, so there are no concrete plans yet, but here are what I currently have in mind:
 
 * Fix whatever is the problem right now (there are a lot of problems right now lol).
+* Add more tensor ops.
+* Proper documentation.
 * GPU acceleration.
 * Some general neural net APIs.
 

package/dist/autograd.d.ts

@@ -6,12 +6,36 @@ export declare enum OP {
     MUL = 3,
     POW = 4,
     DIV = 5,
-    NEG = 6,
-    EXP = 7,
-    LOG = 8,
-    RELU = 9,
-    SIGMOID = 10,
-    TANH = 11
+    GE = 6,
+    LE = 7,
+    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
 }
 export declare class Node {
     value: Tensor;
@@ -26,12 +50,36 @@ 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;
     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;
+    t(): Node;
+    mm(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, neg, exp, log, relu, sigmoid, tanh, ge } = tensor_1.TensorMath;
+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;
 var OP;
 (function (OP) {
     OP[OP["NONE"] = 0] = "NONE";
@@ -11,12 +11,36 @@ 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["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["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 || (exports.OP = OP = {}));
 class Node {
     value;
@@ -61,7 +85,7 @@ class Node {
         out.feedBackward = () => {
             // x * y d/dx = y
             Node.addGrad(this, mul(out.grad, other.value));
-            // x + y d/dy = x
+            // x * y d/dy = x
             Node.addGrad(other, mul(out.grad, this.value));
         };
         return out;
@@ -94,6 +118,46 @@ 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;
+    }
     neg() {
         const out = new Node(neg(this.value), [this], OP.NEG);
         out.feedBackward = () => {
@@ -102,6 +166,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);
@@ -119,6 +296,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 = () => {
@@ -142,6 +343,22 @@ class Node {
         };
         return out;
     }
+    t() {
+        const out = new Node(t(this.value), [this], OP.T);
+        out.feedBackward = () => {
+            Node.addGrad(this, t(out.grad));
+        };
+        return out;
+    }
+    mm(other) {
+        other = Node.forceNode(other);
+        const out = new Node(mm(this.value, other.value), [this, other], OP.MM);
+        out.feedBackward = () => {
+            Node.addGrad(this, mm(out.grad, t(other.value)));
+            Node.addGrad(other, mm(t(this.value), out.grad));
+        };
+        return out;
+    }
     backward() {
         // Build topological order
         const topo = [];

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;
@@ -14,8 +16,25 @@ export declare class TensorMath {
     static le(tA: Tensor, tB: Tensor): Tensor;
     static eq(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;
@@ -23,4 +42,6 @@ export declare class TensorMath {
     static squeeze(tA: Tensor, dims?: number[] | number): Tensor;
     static sumAxis(tA: Tensor, axis: number): Tensor;
     static sum(tA: Tensor, dims?: number[] | number, keepDims?: boolean): Tensor;
+    static t(tA: Tensor): Tensor;
+    static mm(tA: Tensor, tB: 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,116 @@ 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 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")
@@ -315,5 +221,43 @@ class TensorMath {
         }
         return keepDims ? out : TensorMath.squeeze(out, dims);
     }
+    static t(tA) {
+        const shapeA = TensorMath.getShape(tA);
+        if (shapeA.length !== 2)
+            throw new Error("Input is not a matrix");
+        const matA = tA;
+        const matARows = matA.length;
+        const matACols = matA[0].length;
+        const matATranspose = Array.from({ length: matACols }, () => new Array(matARows).fill(0));
+        for (let i = 0; i < matARows; i++) {
+            for (let j = 0; j < matACols; j++) {
+                matATranspose[j][i] = matA[i][j];
+            }
+        }
+        return matATranspose;
+    }
+    static mm(tA, tB) {
+        const shapeA = TensorMath.getShape(tA);
+        const shapeB = TensorMath.getShape(tB);
+        if (shapeA.length !== 2 || shapeB.length !== 2)
+            throw new Error("Inputs are not matrices");
+        const matA = tA;
+        const matB = tB;
+        const matARows = matA.length;
+        const matACols = matA[0].length;
+        const matBRows = matB.length;
+        const matBCols = matB[0].length;
+        if (matACols !== matBRows)
+            throw new Error("Invalid matrices shape for multiplication");
+        const matC = Array.from({ length: matARows }, () => new Array(matBCols).fill(0));
+        for (let i = 0; i < matARows; i++) {
+            for (let j = 0; j < matBCols; j++) {
+                for (let k = 0; k < matACols; k++) {
+                    matC[i][j] += matA[i][k] * matB[k][j];
+                }
+            }
+        }
+        return matC;
+    }
 }
 exports.TensorMath = TensorMath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catniff",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A cute autograd engine for Javascript",
   "main": "index.js",
   "scripts": {
@@ -14,12 +14,18 @@
     "cats",
     "catniff",
     "autograd",
+    "autodiff",
     "ml",
     "dl",
     "ai",
     "maths",
     "gradient",
-    "tensors"
+    "tensors",
+    "library",
+    "framework",
+    "neural-network",
+    "machine-learning",
+    "deep-learning"
   ],
   "author": "nguyenphuminh",
   "license": "GPL-3.0",