scalar-autograd 0.1.3 → 0.1.5

package/dist/Value.spec.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Value_1 = require("./Value");
+function numericalGrad(f, x0, eps = 1e-6) {
+    return (f(x0 + eps) - f(x0 - eps)) / (2 * eps);
+}
+function testUnaryGrad(opName, op, dOp, xval) {
+    const x = new Value_1.Value(xval, "x", true);
+    const y = op(x);
+    y.backward();
+    const analytic = x.grad;
+    const numeric = numericalGrad(z => op(new Value_1.Value(z, "x", false)).data, xval);
+    expect(analytic).toBeCloseTo(numeric, 4);
+}
+function testBinaryGrad(opName, op, dOpA, dOpB, aval, bval) {
+    const a = new Value_1.Value(aval, "a", true);
+    const b = new Value_1.Value(bval, "b", true);
+    const c = op(a, b);
+    c.backward();
+    const analyticA = a.grad;
+    const analyticB = b.grad;
+    const numericA = numericalGrad(x => op(new Value_1.Value(x, "a", false), new Value_1.Value(bval, "b", false)).data, aval);
+    const numericB = numericalGrad(x => op(new Value_1.Value(aval, "a", false), new Value_1.Value(x, "b", false)).data, bval);
+    expect(analyticA).toBeCloseTo(numericA, 4);
+    expect(analyticB).toBeCloseTo(numericB, 4);
+}
+describe('Value autograd system', () => {
+    it('runs the forward and backward pass example', () => {
+        const a = new Value_1.Value(2, 'a', true);
+        const b = new Value_1.Value(-3, 'b', true);
+        const c = new Value_1.Value(10, 'c', true);
+        const e = a.mul(b); // e = a * b
+        const d = e.add(c); // d = e + c
+        const f = d.tanh(); // f = tanh(d)
+        f.backward();
+        expect(Number(a.data)).toBe(2);
+        expect(Number(b.data)).toBe(-3);
+        expect(Number(c.data)).toBe(10);
+        expect(f.toString()).toMatch(/Value\(data=.*?, grad=.*?, label=tanh\(\(.+\)\)\)/);
+        expect(Number.isFinite(a.grad)).toBe(true);
+        expect(Number.isFinite(b.grad)).toBe(true);
+        expect(Number.isFinite(c.grad)).toBe(true);
+    });
+    describe('Value new operators: powValue, mod, cmp, softplus, floor/ceil/round, square/cube, reciprocal, clamp, sum, mean', () => {
+        it('powValue matches number math and gradients', () => {
+            const a = new Value_1.Value(2, 'a', true);
+            const b = new Value_1.Value(3, 'b', true);
+            const c = a.powValue(b);
+            c.backward();
+            // da = b * a^(b-1); db = log(a) * a^b
+            expect(c.data).toBeCloseTo(8);
+            expect(a.grad).toBeCloseTo(3 * (2 ** 2));
+            expect(b.grad).toBeCloseTo(Math.log(2) * 8);
+        });
+        it('mod computes values modulo', () => {
+            const a = new Value_1.Value(7);
+            const b = new Value_1.Value(3);
+            expect(a.mod(b).data).toBeCloseTo(1);
+        });
+        it('cmp functions eq/neq/gt/lt/gte/lte match JS', () => {
+            const a = new Value_1.Value(5);
+            const b = new Value_1.Value(7);
+            expect(a.eq(b).data).toBe(0);
+            expect(b.eq(b).data).toBe(1);
+            expect(a.neq(b).data).toBe(1);
+            expect(b.neq(b).data).toBe(0);
+            expect(a.gt(b).data).toBe(0);
+            expect(b.gt(a).data).toBe(1);
+            expect(a.lt(b).data).toBe(1);
+            expect(b.lt(a).data).toBe(0);
+            expect(a.gte(b).data).toBe(0);
+            expect(b.gte(a).data).toBe(1);
+            expect(a.lte(b).data).toBe(1);
+            expect(b.lte(a).data).toBe(0);
+        });
+        it('softplus and its gradient', () => {
+            const x = new Value_1.Value(0.5, 'x', true);
+            const y = x.softplus();
+            y.backward();
+            expect(y.data).toBeCloseTo(Math.log(1 + Math.exp(0.5)), 5);
+            expect(x.grad).toBeCloseTo(1 / (1 + Math.exp(-0.5)), 5);
+        });
+        it('floor, ceil and round logic', () => {
+            const x = new Value_1.Value(-2.7);
+            expect(x.floor().data).toBe(-3);
+            expect(x.ceil().data).toBe(-2);
+            expect(new Value_1.Value(1.4).round().data).toBe(1);
+            expect(new Value_1.Value(1.6).round().data).toBe(2);
+        });
+        it('square, cube, reciprocal logic', () => {
+            const x = new Value_1.Value(3, 'x', true);
+            const sq = x.square();
+            const cu = x.cube();
+            const rec = x.reciprocal();
+            sq.backward();
+            expect(sq.data).toBe(9);
+            expect(x.grad).toBe(6);
+            x.grad = 0;
+            cu.backward();
+            expect(cu.data).toBe(27);
+            expect(x.grad).toBe(27);
+            x.grad = 0;
+            rec.backward();
+            expect(rec.data).toBeCloseTo(1 / 3);
+            expect(x.grad).toBeCloseTo(-1 / 9);
+        });
+        it('clamp clamps value and only has gradient when in interior', () => {
+            const x = new Value_1.Value(5, 'x', true);
+            const c1 = x.clamp(0, 3);
+            expect(c1.data).toBe(3);
+            c1.backward();
+            expect(x.grad).toBe(0);
+            x.grad = 0;
+            const c2 = x.clamp(0, 10);
+            expect(c2.data).toBe(5);
+            c2.backward();
+            expect(x.grad).toBe(1);
+            x.grad = 0;
+            const c3 = x.clamp(7, 9);
+            expect(c3.data).toBe(7);
+            c3.backward();
+            expect(x.grad).toBe(0);
+        });
+        it('sum and mean logic for array inputs', () => {
+            const vals = [1, 3, 5].map((n, i) => new Value_1.Value(n, 'v' + i, true));
+            const s = Value_1.Value.sum(vals);
+            const m = Value_1.Value.mean(vals);
+            expect(s.data).toBe(9);
+            expect(m.data).toBe(3);
+            m.backward();
+            for (const v of vals)
+                expect(v.grad).toBeCloseTo(1 / 3);
+        });
+    });
+    it('computes gradients only for required nodes (example from user)', () => {
+        const x = new Value_1.Value(2.0, "x", true);
+        const y = new Value_1.Value(3.0, "y", false); // y doesn't require gradients
+        const z = x.mul(y).add(x.pow(2));
+        z.backward();
+        expect(Number(x.grad)).toBeCloseTo(7.0);
+        expect(Number(y.grad)).toBeCloseTo(0.0);
+        expect(x.toString()).toMatch(/Value\(data=2.0000, grad=7.0000, label=x\)/);
+        expect(y.toString()).toMatch(/Value\(data=3.0000, grad=0.0000, label=y\)/);
+    });
+    it('computes gradients for add operation', () => {
+        const a = new Value_1.Value(1.5, 'a', true);
+        const b = new Value_1.Value(-0.7, 'b', true);
+        const c = a.add(b);
+        c.backward();
+        // dc/da = 1, dc/db = 1
+        expect(a.grad).toBeCloseTo(1.0);
+        expect(b.grad).toBeCloseTo(1.0);
+    });
+    it('computes gradients for mul operation', () => {
+        const a = new Value_1.Value(2, 'a', true);
+        const b = new Value_1.Value(3, 'b', true);
+        const c = a.mul(b);
+        c.backward();
+        // dc/da = b, dc/db = a
+        expect(a.grad).toBeCloseTo(3.0);
+        expect(b.grad).toBeCloseTo(2.0);
+    });
+    it('computes gradients for sub operation', () => {
+        const a = new Value_1.Value(2.5, 'a', true);
+        const b = new Value_1.Value(1.2, 'b', true);
+        const c = a.sub(b);
+        c.backward();
+        // dc/da = 1, dc/db = -1
+        expect(a.grad).toBeCloseTo(1.0);
+        expect(b.grad).toBeCloseTo(-1.0);
+    });
+    it('computes gradients for div operation', () => {
+        const a = new Value_1.Value(6, 'a', true);
+        const b = new Value_1.Value(2, 'b', true);
+        const c = a.div(b);
+        c.backward();
+        // dc/da = 1/b, dc/db = -a/b^2
+        expect(a.grad).toBeCloseTo(0.5);
+        expect(b.grad).toBeCloseTo(-1.5);
+    });
+    it('computes gradients for pow operation', () => {
+        const a = new Value_1.Value(4, 'a', true);
+        const c = a.pow(3);
+        c.backward();
+        // dc/da = 3*a^2 = 48
+        expect(a.grad).toBeCloseTo(48.0);
+    });
+    it('computes gradients for tanh operation', () => {
+        const a = new Value_1.Value(1, 'a', true);
+        const c = a.tanh();
+        c.backward();
+        // dc/da = 1-tanh(a)^2
+        const t = Math.tanh(1);
+        expect(a.grad).toBeCloseTo(1 - t * t);
+    });
+    it('computes gradients for sigmoid operation', () => {
+        const a = new Value_1.Value(0.7, 'a', true);
+        const c = a.sigmoid();
+        c.backward();
+        // dc/da = sigmoid(a)*(1-sigmoid(a))
+        const s = 1 / (1 + Math.exp(-0.7));
+        expect(a.grad).toBeCloseTo(s * (1 - s));
+    });
+    it('does not track graph when using Value.withNoGrad', () => {
+        const a = new Value_1.Value(5, 'a', true);
+        const b = new Value_1.Value(7, 'b', true);
+        let c = undefined;
+        Value_1.Value.withNoGrad(() => {
+            c = a.add(b);
+        });
+        expect(c).toBeDefined();
+        expect(c.requiresGrad).toBe(false);
+        expect(c['prev'].length).toBe(0);
+        c.backward();
+        expect(a.grad).toBe(0);
+        expect(b.grad).toBe(0);
+    });
+});
+describe('Value unary and binary operators: trigs, relu, abs, exp/log, min/max', () => {
+    // Numerical vs analytic gradient checks for unary operators
+    it('numerical gradient: sin', () => testUnaryGrad('sin', x => x.sin(), x => Math.cos(x), 1.1));
+    it('numerical gradient: cos', () => testUnaryGrad('cos', x => x.cos(), x => -Math.sin(x), 0.5));
+    it('numerical gradient: tan', () => testUnaryGrad('tan', x => x.tan(), x => 1 / (Math.cos(x) ** 2), 0.8));
+    it('numerical gradient: asin', () => testUnaryGrad('asin', x => x.asin(), x => 1 / Math.sqrt(1 - x * x), 0.25));
+    it('numerical gradient: acos', () => testUnaryGrad('acos', x => x.acos(), x => -1 / Math.sqrt(1 - x * x), 0.25));
+    it('numerical gradient: atan', () => testUnaryGrad('atan', x => x.atan(), x => 1 / (1 + x * x), 1.3));
+    it('numerical gradient: relu', () => testUnaryGrad('relu', x => x.relu(), x => (x > 0 ? 1 : 0), 3.0));
+    it('numerical gradient: abs', () => testUnaryGrad('abs', x => x.abs(), x => (x >= 0 ? 1 : -1), -3));
+    it('numerical gradient: exp', () => testUnaryGrad('exp', x => x.exp(), x => Math.exp(x), 1.2));
+    it('numerical gradient: log', () => testUnaryGrad('log', x => x.log(), x => 1 / x, 1.5));
+    it('numerical gradient: tanh', () => testUnaryGrad('tanh', x => x.tanh(), x => 1 - Math.tanh(x) ** 2, 0.9));
+    it('numerical gradient: sigmoid', () => testUnaryGrad('sigmoid', x => x.sigmoid(), x => { const s = 1 / (1 + Math.exp(-x)); return s * (1 - s); }, 0.7));
+    // Numerical vs analytic gradient checks for binary operators
+    it('numerical gradient: add', () => testBinaryGrad('add', (a, b) => a.add(b), (a, b) => 1, (a, b) => 1, 1.3, -2.1));
+    it('numerical gradient: sub', () => testBinaryGrad('sub', (a, b) => a.sub(b), (a, b) => 1, (a, b) => -1, 5.2, -1.2));
+    it('numerical gradient: mul', () => testBinaryGrad('mul', (a, b) => a.mul(b), (a, b) => b, (a, b) => a, 1.7, 2.5));
+    it('numerical gradient: div', () => testBinaryGrad('div', (a, b) => a.div(b), (a, b) => 1 / b, (a, b) => -a / (b * b), 4.0, -2.2));
+    it('numerical gradient: pow', () => {
+        const exp = 3.3;
+        const grad = (a) => exp * Math.pow(a, exp - 1);
+        testUnaryGrad('pow', x => x.pow(exp), grad, 2.0);
+    });
+    it('numerical gradient: min', () => testBinaryGrad('min', (a, b) => a.min(b), (a, b) => a < b ? 1 : 0, (a, b) => b < a ? 1 : 0, -1.0, 0.8));
+    it('numerical gradient: max', () => testBinaryGrad('max', (a, b) => a.max(b), (a, b) => a > b ? 1 : 0, (a, b) => b > a ? 1 : 0, 2.3, -4.5));
+});

package/dist/ValueActivation.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueActivation = void 0;
+const Value_1 = require("./Value");
+class ValueActivation {
+    static relu(x) {
+        const r = Math.max(0, x.data);
+        return Value_1.Value.make(r, x, null, (out) => () => {
+            if (x.requiresGrad)
+                x.grad += (x.data > 0 ? 1 : 0) * out.grad;
+        }, `relu(${x.label})`);
+    }
+    static softplus(x) {
+        const s = Math.log(1 + Math.exp(x.data));
+        return Value_1.Value.make(s, x, null, (out) => () => {
+            x.grad += 1 / (1 + Math.exp(-x.data)) * out.grad;
+        }, `softplus(${x.label})`);
+    }
+    static tanh(x) {
+        const t = Math.tanh(x.data);
+        return Value_1.Value.make(t, x, null, (out) => () => {
+            if (x.requiresGrad)
+                x.grad += (1 - t ** 2) * out.grad;
+        }, `tanh(${x.label})`);
+    }
+    static sigmoid(x) {
+        const s = 1 / (1 + Math.exp(-x.data));
+        return Value_1.Value.make(s, x, null, (out) => () => {
+            if (x.requiresGrad)
+                x.grad += s * (1 - s) * out.grad;
+        }, `sigmoid(${x.label})`);
+    }
+}
+exports.ValueActivation = ValueActivation;

package/dist/ValueArithmetic.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueArithmetic = void 0;
+const Value_1 = require("./Value");
+class ValueArithmetic {
+    static add(a, b) {
+        return Value_1.Value.make(a.data + b.data, a, b, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += 1 * out.grad;
+            if (b.requiresGrad)
+                b.grad += 1 * out.grad;
+        }, `(${a.label}+${b.label})`);
+    }
+    static sqrt(a) {
+        if (a.data < 0) {
+            throw new Error(`Cannot take sqrt of negative number: ${a.data}`);
+        }
+        const root = Math.sqrt(a.data);
+        return Value_1.Value.make(root, a, null, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += 0.5 / root * out.grad;
+        }, `sqrt(${a.label})`);
+    }
+    static mul(a, b) {
+        return Value_1.Value.make(a.data * b.data, a, b, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += b.data * out.grad;
+            if (b.requiresGrad)
+                b.grad += a.data * out.grad;
+        }, `(${a.label}*${b.label})`);
+    }
+    static sub(a, b) {
+        return Value_1.Value.make(a.data - b.data, a, b, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += 1 * out.grad;
+            if (b.requiresGrad)
+                b.grad -= 1 * out.grad;
+        }, `(${a.label}-${b.label})`);
+    }
+    static div(a, b, eps = 1e-12) {
+        if (Math.abs(b.data) < eps) {
+            throw new Error(`Division by zero or near-zero encountered in div: denominator=${b.data}`);
+        }
+        const safe = b.data;
+        return Value_1.Value.make(a.data / safe, a, b, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += (1 / safe) * out.grad;
+            if (b.requiresGrad)
+                b.grad -= (a.data / (safe ** 2)) * out.grad;
+        }, `(${a.label}/${b.label})`);
+    }
+    static pow(a, exp) {
+        if (typeof exp !== "number" || Number.isNaN(exp) || !Number.isFinite(exp)) {
+            throw new Error(`Exponent must be a finite number, got ${exp}`);
+        }
+        if (a.data < 0 && Math.abs(exp % 1) > 1e-12) {
+            throw new Error(`Cannot raise negative base (${a.data}) to non-integer exponent (${exp})`);
+        }
+        const safeBase = a.data;
+        return Value_1.Value.make(Math.pow(safeBase, exp), a, null, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += exp * Math.pow(safeBase, exp - 1) * out.grad;
+        }, `(${a.label}^${exp})`);
+    }
+    static powValue(a, b, eps = 1e-12) {
+        if (a.data < 0 && Math.abs(b.data % 1) > eps) {
+            throw new Error(`Cannot raise negative base (${a.data}) to non-integer exponent (${b.data})`);
+        }
+        if (a.data === 0 && b.data <= 0) {
+            throw new Error(`0 cannot be raised to zero or negative power: ${b.data}`);
+        }
+        const safeBase = a.data;
+        return Value_1.Value.make(Math.pow(safeBase, b.data), a, b, (out) => () => {
+            a.grad += b.data * Math.pow(safeBase, b.data - 1) * out.grad;
+            b.grad += Math.log(Math.max(eps, safeBase)) * Math.pow(safeBase, b.data) * out.grad;
+        }, `(${a.label}^${b.label})`);
+    }
+    static mod(a, b) {
+        if (typeof b.data !== 'number' || b.data === 0) {
+            throw new Error(`Modulo by zero encountered`);
+        }
+        return Value_1.Value.make(a.data % b.data, a, b, (out) => () => {
+            a.grad += 1 * out.grad;
+            // No grad to b (modulus not used in most diff cases)
+        }, `(${a.label}%${b.label})`);
+    }
+    static abs(a) {
+        const d = Math.abs(a.data);
+        return Value_1.Value.make(d, a, null, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += (a.data >= 0 ? 1 : -1) * out.grad;
+        }, `abs(${a.label})`);
+    }
+    static exp(a) {
+        const e = Math.exp(a.data);
+        return Value_1.Value.make(e, a, null, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += e * out.grad;
+        }, `exp(${a.label})`);
+    }
+    static log(a, eps = 1e-12) {
+        if (a.data <= 0) {
+            throw new Error(`Logarithm undefined for non-positive value: ${a.data}`);
+        }
+        const safe = Math.max(a.data, eps);
+        const l = Math.log(safe);
+        return Value_1.Value.make(l, a, null, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += (1 / safe) * out.grad;
+        }, `log(${a.label})`);
+    }
+    static min(a, b) {
+        const d = Math.min(a.data, b.data);
+        return Value_1.Value.make(d, a, b, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += (a.data < b.data ? 1 : 0) * out.grad;
+            if (b.requiresGrad)
+                b.grad += (b.data < a.data ? 1 : 0) * out.grad;
+        }, `min(${a.label},${b.label})`);
+    }
+    static max(a, b) {
+        const d = Math.max(a.data, b.data);
+        return Value_1.Value.make(d, a, b, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += (a.data > b.data ? 1 : 0) * out.grad;
+            if (b.requiresGrad)
+                b.grad += (b.data > a.data ? 1 : 0) * out.grad;
+        }, `max(${a.label},${b.label})`);
+    }
+    static floor(a) {
+        const fl = Math.floor(a.data);
+        return Value_1.Value.make(fl, a, null, () => () => { }, `floor(${a.label})`);
+    }
+    static ceil(a) {
+        const cl = Math.ceil(a.data);
+        return Value_1.Value.make(cl, a, null, () => () => { }, `ceil(${a.label})`);
+    }
+    static round(a) {
+        const rd = Math.round(a.data);
+        return Value_1.Value.make(rd, a, null, () => () => { }, `round(${a.label})`);
+    }
+    static square(a) {
+        return ValueArithmetic.pow(a, 2);
+    }
+    static cube(a) {
+        return ValueArithmetic.pow(a, 3);
+    }
+    static reciprocal(a, eps = 1e-12) {
+        if (Math.abs(a.data) < eps) {
+            throw new Error(`Reciprocal of zero or near-zero detected`);
+        }
+        return Value_1.Value.make(1 / a.data, a, null, (out) => () => {
+            if (a.requiresGrad)
+                a.grad += -1 / (a.data * a.data) * out.grad;
+        }, `reciprocal(${a.label})`);
+    }
+    static clamp(a, min, max) {
+        let val = Math.max(min, Math.min(a.data, max));
+        return Value_1.Value.make(val, a, null, (out) => () => {
+            a.grad += (a.data > min && a.data < max ? 1 : 0) * out.grad;
+        }, `clamp(${a.label},${min},${max})`);
+    }
+    static sum(vals) {
+        if (!vals.length)
+            return new Value_1.Value(0);
+        return vals.reduce((a, b) => a.add(b));
+    }
+    static mean(vals) {
+        if (!vals.length)
+            return new Value_1.Value(0);
+        return ValueArithmetic.sum(vals).div(vals.length);
+    }
+    static neg(a) {
+        return Value_1.Value.make(-a.data, a, null, (out) => () => {
+            if (a.requiresGrad)
+                a.grad -= out.grad;
+        }, `(-${a.label})`);
+    }
+}
+exports.ValueArithmetic = ValueArithmetic;

package/dist/ValueComparison.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueComparison = void 0;
+const Value_1 = require("./Value");
+class ValueComparison {
+    static eq(a, b) {
+        return Value_1.Value.make(a.data === b.data ? 1 : 0, a, b, (out) => () => {
+            // No gradient - discrete operation
+        }, `(${a.label}==${b.label})`);
+    }
+    static ifThenElse(cond, thenVal, elseVal) {
+        return Value_1.Value.make(cond.data ? thenVal.data : elseVal.data, cond, cond.data ? thenVal : elseVal, (out) => () => {
+            if (cond.data) {
+                thenVal.grad += out.grad;
+            }
+            else {
+                elseVal.grad += out.grad;
+            }
+        }, `if(${cond.label}){${thenVal.label}}else{${elseVal.label}}`);
+    }
+    static neq(a, b) {
+        return Value_1.Value.make(a.data !== b.data ? 1 : 0, a, b, (out) => () => {
+            // No gradient - discrete operation
+        }, `(${a.label}!=${b.label})`);
+    }
+    static gt(a, b) {
+        return Value_1.Value.make(a.data > b.data ? 1 : 0, a, b, (out) => () => {
+            // No gradient - discrete operation
+        }, `(${a.label}>${b.label})`);
+    }
+    static lt(a, b) {
+        return Value_1.Value.make(a.data < b.data ? 1 : 0, a, b, (out) => () => {
+            // No gradient - discrete operation
+        }, `(${a.label}<${b.label})`);
+    }
+    static gte(a, b) {
+        return Value_1.Value.make(a.data >= b.data ? 1 : 0, a, b, (out) => () => {
+            // No gradient - discrete operation
+        }, `(${a.label}>=${b.label})`);
+    }
+    static lte(a, b) {
+        return Value_1.Value.make(a.data <= b.data ? 1 : 0, a, b, (out) => () => {
+            // No gradient - discrete operation
+        }, `(${a.label}<=${b.label})`);
+    }
+}
+exports.ValueComparison = ValueComparison;

package/dist/ValueTrig.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueTrig = void 0;
+const Value_1 = require("./Value");
+class ValueTrig {
+    static sin(x) {
+        const s = Math.sin(x.data);
+        return Value_1.Value.make(s, x, null, (out) => () => {
+            if (x.requiresGrad)
+                x.grad += Math.cos(x.data) * out.grad;
+        }, `sin(${x.label})`);
+    }
+    static cos(x) {
+        const c = Math.cos(x.data);
+        return Value_1.Value.make(c, x, null, (out) => () => {
+            if (x.requiresGrad)
+                x.grad += -Math.sin(x.data) * out.grad;
+        }, `cos(${x.label})`);
+    }
+    static tan(x) {
+        const t = Math.tan(x.data);
+        return Value_1.Value.make(t, x, null, (out) => () => {
+            if (x.requiresGrad)
+                x.grad += (1 / (Math.cos(x.data) ** 2)) * out.grad;
+        }, `tan(${x.label})`);
+    }
+    static asin(x) {
+        const s = Math.asin(x.data);
+        return Value_1.Value.make(s, x, null, (out) => () => {
+            if (x.requiresGrad)
+                x.grad += (1 / Math.sqrt(1 - x.data * x.data)) * out.grad;
+        }, `asin(${x.label})`);
+    }
+    static acos(x) {
+        const c = Math.acos(x.data);
+        return Value_1.Value.make(c, x, null, (out) => () => {
+            if (x.requiresGrad)
+                x.grad += (-1 / Math.sqrt(1 - x.data * x.data)) * out.grad;
+        }, `acos(${x.label})`);
+    }
+    static atan(x) {
+        const a = Math.atan(x.data);
+        return Value_1.Value.make(a, x, null, (out) => () => {
+            if (x.requiresGrad)
+                x.grad += (1 / (1 + x.data * x.data)) * out.grad;
+        }, `atan(${x.label})`);
+    }
+}
+exports.ValueTrig = ValueTrig;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "scalar-autograd",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Scalar-based reverse-mode automatic differentiation in TypeScript.",
-  "main": "Value.js",
-  "types": "Value.d.ts",
+  "main": "dist/Value.js",
+  "types": "dist/Value.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/mfagerlund/ScalarAutograd.git"
@@ -18,15 +18,7 @@
   "author": "Mattias Fagerlund <mattias.fagerlund@carretera.se>",
   "license": "MIT",
   "files": [
-    "Value.js",
-    "Value.d.ts",
-    "V.ts",
-    "Value*.js",
-    "Value*.ts",
-    "Losses.js",
-    "Losses.ts",
-    "Optimizers.js",
-    "Optimizers.ts"
+    "dist/"
   ],
   "devDependencies": {
     "ts-node": "^10.0.0",