scalar-autograd 0.1.7 → 0.1.9

package/dist/Value.js

@@ -1,32 +1,86 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Value = exports.Losses = exports.AdamW = exports.Adam = exports.SGD = exports.Optimizer = exports.V = void 0;
-var V_1 = require("./V");
-Object.defineProperty(exports, "V", { enumerable: true, get: function () { return V_1.V; } });
-var Optimizers_1 = require("./Optimizers");
-Object.defineProperty(exports, "Optimizer", { enumerable: true, get: function () { return Optimizers_1.Optimizer; } });
-Object.defineProperty(exports, "SGD", { enumerable: true, get: function () { return Optimizers_1.SGD; } });
-Object.defineProperty(exports, "Adam", { enumerable: true, get: function () { return Optimizers_1.Adam; } });
-Object.defineProperty(exports, "AdamW", { enumerable: true, get: function () { return Optimizers_1.AdamW; } });
-var Losses_1 = require("./Losses");
-Object.defineProperty(exports, "Losses", { enumerable: true, get: function () { return Losses_1.Losses; } });
+export { V } from './V';
+export { Optimizer, SGD, Adam, AdamW } from './Optimizers';
+export { Losses } from './Losses';
+export { Vec2 } from './Vec2';
+export { Vec3 } from './Vec3';
 const EPS = 1e-12;
-const ValueTrig_1 = require("./ValueTrig");
-const ValueActivation_1 = require("./ValueActivation");
-const ValueArithmetic_1 = require("./ValueArithmetic");
-const ValueComparison_1 = require("./ValueComparison");
-class Value {
+import { ValueActivation } from './ValueActivation';
+import { ValueArithmetic } from './ValueArithmetic';
+import { ValueComparison } from './ValueComparison';
+import { ValueTrig } from './ValueTrig';
+/**
+ * Represents a scalar value in the computational graph for automatic differentiation.
+ * Supports forward computation and reverse-mode autodiff (backpropagation).
+ * @public
+ */
+export class Value {
+    /**
+     * Global flag to disable gradient tracking. Use Value.withNoGrad() instead of setting directly.
+     * @public
+     */
     static no_grad_mode = false;
+    /**
+     * Current graph builder for incremental hash tracking (null when not building).
+     * @internal
+     */
+    static currentBuilder = null;
+    /**
+     * Global counter for unique Value IDs.
+     * @internal
+     */
+    static nextId = 0;
+    /**
+     * Unique ID for this Value instance (for hashing intermediate nodes).
+     * @internal
+     */
+    _id;
+    /**
+     * The numeric value stored in this node.
+     * @public
+     */
     data;
+    /**
+     * The gradient of the output with respect to this value.
+     * @public
+     */
     grad = 0;
+    /**
+     * Whether this value participates in gradient computation.
+     * @public
+     */
     requiresGrad;
     backwardFn = () => { };
-    prev = [];
+    /** @internal */ prev = [];
+    /**
+     * Optional label for debugging and visualization.
+     * @public
+     */
     label;
+    /**
+     * Operation type for JIT compilation (e.g., '+', 'exp', 'sin').
+     * @internal
+     */
+    _op;
+    /**
+     * Parameter name for JIT compilation inputs.
+     * @internal
+     */
+    paramName;
+    /**
+     * Registry ID for kernel reuse system.
+     * @internal
+     */
+    _registryId;
+    /**
+     * Operation constants (e.g., min/max for clamp, exponent for pow).
+     * @internal
+     */
+    _opConstants;
     constructor(data, label = "", requiresGrad = false) {
         if (typeof data !== 'number' || Number.isNaN(data) || !Number.isFinite(data)) {
             throw new Error(`Invalid number passed to Value: ${data}`);
         }
+        this._id = Value.nextId++;
         this.data = data;
         this.label = label;
         this.requiresGrad = requiresGrad;
@@ -39,70 +93,70 @@ class Value {
      * @returns New Value with sin.
      */
     sin() {
-        return ValueTrig_1.ValueTrig.sin(this);
+        return ValueTrig.sin(this);
     }
     /**
      * Returns cos(this).
      * @returns New Value with cos.
      */
     cos() {
-        return ValueTrig_1.ValueTrig.cos(this);
+        return ValueTrig.cos(this);
     }
     /**
      * Returns tan(this).
      * @returns New Value with tan.
      */
     tan() {
-        return ValueTrig_1.ValueTrig.tan(this);
+        return ValueTrig.tan(this);
     }
     /**
      * Returns asin(this).
      * @returns New Value with asin.
      */
     asin() {
-        return ValueTrig_1.ValueTrig.asin(this);
+        return ValueTrig.asin(this);
     }
     /**
      * Returns acos(this).
      * @returns New Value with acos.
      */
     acos() {
-        return ValueTrig_1.ValueTrig.acos(this);
+        return ValueTrig.acos(this);
     }
     /**
      * Returns atan(this).
      * @returns New Value with atan.
      */
     atan() {
-        return ValueTrig_1.ValueTrig.atan(this);
+        return ValueTrig.atan(this);
     }
     /**
      * Returns relu(this).
      * @returns New Value with relu.
      */
     relu() {
-        return ValueActivation_1.ValueActivation.relu(this);
+        return ValueActivation.relu(this);
     }
     /**
      * Returns abs(this).
      * @returns New Value with abs.
      */
     abs() {
-        return ValueArithmetic_1.ValueArithmetic.abs(this);
+        return ValueArithmetic.abs(this);
     }
     /**
      * Returns exp(this).
      * @returns New Value with exp.
      */
     exp() {
-        return ValueArithmetic_1.ValueArithmetic.exp(this);
+        return ValueArithmetic.exp(this);
     }
     /**
      * Returns log(this).
      * @returns New Value with log.
      */
     log() {
-        return ValueArithmetic_1.ValueArithmetic.log(this, EPS);
+        return ValueArithmetic.log(this, EPS);
     }
     /**
      * Returns min(this, other).
@@ -110,7 +164,7 @@ class Value {
      * @returns New Value with min.
      */
     min(other) {
-        return ValueArithmetic_1.ValueArithmetic.min(this, other);
+        return ValueArithmetic.min(this, other);
     }
     /**
      * Returns max(this, other).
@@ -118,7 +172,7 @@ class Value {
      * @returns New Value with max.
      */
     max(other) {
-        return ValueArithmetic_1.ValueArithmetic.max(this, other);
+        return ValueArithmetic.max(this, other);
     }
     /**
      * Adds this and other.
@@ -126,7 +180,7 @@ class Value {
      * @returns New Value with sum.
      */
     add(other) {
-        return ValueArithmetic_1.ValueArithmetic.add(this, Value.ensureValue(other));
+        return ValueArithmetic.add(this, Value.ensureValue(other));
     }
     /**
      * Multiplies this and other.
@@ -134,7 +188,7 @@ class Value {
      * @returns New Value with product.
      */
     mul(other) {
-        return ValueArithmetic_1.ValueArithmetic.mul(this, Value.ensureValue(other));
+        return ValueArithmetic.mul(this, Value.ensureValue(other));
     }
     /**
      * Subtracts other from this.
@@ -142,7 +196,7 @@ class Value {
      * @returns New Value with difference.
      */
     sub(other) {
-        return ValueArithmetic_1.ValueArithmetic.sub(this, Value.ensureValue(other));
+        return ValueArithmetic.sub(this, Value.ensureValue(other));
     }
     /**
      * Divides this by other.
@@ -150,7 +204,7 @@ class Value {
      * @returns New Value with quotient.
      */
     div(other) {
-        return ValueArithmetic_1.ValueArithmetic.div(this, Value.ensureValue(other), EPS);
+        return ValueArithmetic.div(this, Value.ensureValue(other), EPS);
     }
     /**
      * Raises this to the power exp.
@@ -158,7 +212,7 @@ class Value {
      * @returns New Value with pow(this, exp)
      */
     pow(exp) {
-        return ValueArithmetic_1.ValueArithmetic.pow(this, exp);
+        return ValueArithmetic.pow(this, exp);
     }
     /**
      * Raises this to a dynamic Value (other).
@@ -166,7 +220,7 @@ class Value {
      * @returns New Value with pow(this, other)
      */
     powValue(other) {
-        return ValueArithmetic_1.ValueArithmetic.powValue(this, Value.ensureValue(other), EPS);
+        return ValueArithmetic.powValue(this, Value.ensureValue(other), EPS);
     }
     /**
      * Returns this modulo other.
@@ -174,7 +228,7 @@ class Value {
      * @returns New Value with modulo.
      */
     mod(other) {
-        return ValueArithmetic_1.ValueArithmetic.mod(this, other);
+        return ValueArithmetic.mod(this, other);
     }
     /**
      * Returns Value indicating if this equals other.
@@ -182,7 +236,7 @@ class Value {
      * @returns New Value (1 if equal, else 0)
      */
     eq(other) {
-        return ValueComparison_1.ValueComparison.eq(this, other);
+        return ValueComparison.eq(this, other);
     }
     /**
      * Returns Value indicating if this not equals other.
@@ -190,7 +244,7 @@ class Value {
      * @returns New Value (1 if not equal, else 0)
      */
     neq(other) {
-        return ValueComparison_1.ValueComparison.neq(this, other);
+        return ValueComparison.neq(this, other);
     }
     /**
      * Returns Value indicating if this greater than other.
@@ -198,7 +252,7 @@ class Value {
      * @returns New Value (1 if true, else 0)
      */
     gt(other) {
-        return ValueComparison_1.ValueComparison.gt(this, other);
+        return ValueComparison.gt(this, other);
     }
     /**
      * Returns Value indicating if this less than other.
@@ -206,7 +260,7 @@ class Value {
      * @returns New Value (1 if true, else 0)
      */
     lt(other) {
-        return ValueComparison_1.ValueComparison.lt(this, other);
+        return ValueComparison.lt(this, other);
     }
     /**
      * Returns Value indicating if this greater than or equal to other.
@@ -214,7 +268,7 @@ class Value {
      * @returns New Value (1 if true, else 0)
      */
     gte(other) {
-        return ValueComparison_1.ValueComparison.gte(this, other);
+        return ValueComparison.gte(this, other);
     }
     /**
      * Returns Value indicating if this less than or equal to other.
@@ -222,56 +276,56 @@ class Value {
      * @returns New Value (1 if true, else 0)
      */
     lte(other) {
-        return ValueComparison_1.ValueComparison.lte(this, other);
+        return ValueComparison.lte(this, other);
     }
     /**
      * Returns softplus(this).
      * @returns New Value with softplus.
      */
     softplus() {
-        return ValueActivation_1.ValueActivation.softplus(this);
+        return ValueActivation.softplus(this);
     }
     /**
      * Returns the floor of this Value.
      * @returns New Value with floor(data).
      */
     floor() {
-        return ValueArithmetic_1.ValueArithmetic.floor(this);
+        return ValueArithmetic.floor(this);
     }
     /**
      * Returns the ceiling of this Value.
      * @returns New Value with ceil(data).
      */
     ceil() {
-        return ValueArithmetic_1.ValueArithmetic.ceil(this);
+        return ValueArithmetic.ceil(this);
     }
     /**
      * Returns the rounded value of this Value.
      * @returns New Value with rounded data.
      */
     round() {
-        return ValueArithmetic_1.ValueArithmetic.round(this);
+        return ValueArithmetic.round(this);
     }
     /**
      * Returns the square of this Value.
      * @returns New Value with squared data.
      */
     square() {
-        return ValueArithmetic_1.ValueArithmetic.square(this);
+        return ValueArithmetic.square(this);
     }
     /**
      * Returns the cube of this Value.
      * @returns New Value with cubed data.
      */
     cube() {
-        return ValueArithmetic_1.ValueArithmetic.cube(this);
+        return ValueArithmetic.cube(this);
     }
     /**
      * Returns the reciprocal (1/x) of this Value.
      * @returns New Value with reciprocal.
      */
     reciprocal() {
-        return ValueArithmetic_1.ValueArithmetic.reciprocal(this, EPS);
+        return ValueArithmetic.reciprocal(this, EPS);
     }
     /**
      * Clamps this between min and max.
@@ -280,14 +334,21 @@ class Value {
      * @returns New clamped Value
      */
     clamp(min, max) {
-        return ValueArithmetic_1.ValueArithmetic.clamp(this, min, max);
+        return ValueArithmetic.clamp(this, min, max);
     }
     /**
      * Returns the negation (-this) Value.
      * @returns New Value which is the negation.
      */
     neg() {
-        return ValueArithmetic_1.ValueArithmetic.neg(this);
+        return ValueArithmetic.neg(this);
+    }
+    /**
+     * Returns sign(this).
+     * @returns New Value with sign.
+     */
+    sign() {
+        return ValueArithmetic.sign(this);
     }
     /**
      * Returns the sum of the given Values.
@@ -295,7 +356,7 @@ class Value {
      * @returns New Value holding their sum.
      */
     static sum(vals) {
-        return ValueArithmetic_1.ValueArithmetic.sum(vals);
+        return ValueArithmetic.sum(vals);
     }
     /**
      * Returns the mean of the given Values.
@@ -303,21 +364,21 @@ class Value {
      * @returns New Value holding their mean.
      */
     static mean(vals) {
-        return ValueArithmetic_1.ValueArithmetic.mean(vals);
+        return ValueArithmetic.mean(vals);
     }
     /**
      * Returns tanh(this).
      * @returns New Value with tanh.
      */
     tanh() {
-        return ValueActivation_1.ValueActivation.tanh(this);
+        return ValueActivation.tanh(this);
     }
     /**
      * Returns sigmoid(this).
      * @returns New Value with sigmoid.
      */
     sigmoid() {
-        return ValueActivation_1.ValueActivation.sigmoid(this);
+        return ValueActivation.sigmoid(this);
     }
     /**
      * Performs a reverse-mode autodiff backward pass from this Value.
@@ -388,15 +449,39 @@ class Value {
      * @param right Right operand Value or null
      * @param backwardFnBuilder Function to create backward closure
      * @param label Node label for debugging
+     * @param op Operation name for JIT compilation
      * @returns New Value node
      */
-    static make(data, left, right, backwardFnBuilder, label) {
+    static make(data, left, right, backwardFnBuilder, label, op) {
         const requiresGrad = !Value.no_grad_mode && [left, right].filter(Boolean).some(v => v.requiresGrad);
         const out = new Value(data, label, requiresGrad);
         out.prev = Value.no_grad_mode ? [] : [left, right].filter(Boolean);
+        out._op = op;
         if (requiresGrad) {
             out.backwardFn = backwardFnBuilder(out);
         }
+        if (Value.currentBuilder) {
+            Value.currentBuilder.recordOp(out);
+        }
+        return out;
+    }
+    /**
+     * N-ary operation helper for operations with multiple inputs
+     *
+     * TODO: Move code generation logic into makeNary instead of centralized switches.
+     * This would co-locate runtime and codegen logic at operation definition sites.
+     */
+    static makeNary(data, inputs, backwardFnBuilder, label, op) {
+        const requiresGrad = !Value.no_grad_mode && inputs.some(v => v.requiresGrad);
+        const out = new Value(data, label, requiresGrad);
+        out.prev = Value.no_grad_mode ? [] : inputs;
+        out._op = op;
+        if (requiresGrad) {
+            out.backwardFn = backwardFnBuilder(out);
+        }
+        if (Value.currentBuilder) {
+            Value.currentBuilder.recordOp(out);
+        }
         return out;
     }
     /**
@@ -420,5 +505,158 @@ class Value {
             Value.no_grad_mode = prev;
         }
     }
+    // TODO: Move code generation into make/makeNary to co-locate with runtime logic
+    getForwardCode(childCodes) {
+        if (this.paramName)
+            return this.paramName;
+        if (this.prev.length === 1) {
+            const [child] = childCodes;
+            switch (this._op) {
+                case 'exp': return `Math.exp(${child})`;
+                case 'log': return `Math.log(${child})`;
+                case 'sqrt': return `Math.sqrt(${child})`;
+                case 'tanh': return `Math.tanh(${child})`;
+                case 'sigmoid': return `(1 / (1 + Math.exp(-${child})))`;
+                case 'relu': return `Math.max(0, ${child})`;
+                case 'sin': return `Math.sin(${child})`;
+                case 'cos': return `Math.cos(${child})`;
+                case 'tan': return `Math.tan(${child})`;
+                case 'asin': return `Math.asin(${child})`;
+                case 'acos': return `Math.acos(${child})`;
+                case 'atan': return `Math.atan(${child})`;
+                case 'neg': return `(-${child})`;
+                case 'abs': return `Math.abs(${child})`;
+                case 'square': return `(${child} * ${child})`;
+                case 'cube': return `(${child} * ${child} * ${child})`;
+                case 'reciprocal': return `(1 / ${child})`;
+                case 'sign': return `Math.sign(${child})`;
+                case 'softplus': return `Math.log(1 + Math.exp(${child}))`;
+                case 'floor': return `Math.floor(${child})`;
+                case 'ceil': return `Math.ceil(${child})`;
+                case 'round': return `Math.round(${child})`;
+                case 'clamp': {
+                    const [min, max] = this._opConstants || [0, 1];
+                    return `Math.max(${min}, Math.min(${child}, ${max}))`;
+                }
+                default: return String(this.data);
+            }
+        }
+        // N-ary operations (6 inputs)
+        if (this.prev.length === 6 && this._op === 'eigenvalue_custom') {
+            const [c00, c01, c02, c11, c12, c22] = childCodes;
+            return `window.__eigenHelpers.computeSmallestEigenvalue(${c00}, ${c01}, ${c02}, ${c11}, ${c12}, ${c22})`;
+        }
+        const [left, right] = childCodes;
+        switch (this._op) {
+            case '+': return `(${left} + ${right})`;
+            case '-': return `(${left} - ${right})`;
+            case '*': return `(${left} * ${right})`;
+            case '/': return `(${left} / ${right})`;
+            case 'powValue': return `Math.pow(${left}, ${right})`;
+            case 'mod': return `(${left} % ${right})`;
+            case 'min': return `Math.min(${left}, ${right})`;
+            case 'max': return `Math.max(${left}, ${right})`;
+            default: return String(this.data);
+        }
+    }
+    // TODO: Move code generation into make/makeNary to co-locate with runtime logic
+    getBackwardCode(gradVar, childGrads, childVars) {
+        if (this.prev.length === 1) {
+            const [childGrad] = childGrads;
+            const [child] = childVars;
+            switch (this._op) {
+                case 'exp':
+                    return `${childGrad} += ${gradVar} * Math.exp(${child});`;
+                case 'log':
+                    return `${childGrad} += ${gradVar} / ${child};`;
+                case 'sqrt':
+                    return `${childGrad} += ${gradVar} * 0.5 / Math.sqrt(${child});`;
+                case 'tanh': {
+                    const tanhChild = `Math.tanh(${child})`;
+                    return `${childGrad} += ${gradVar} * (1 - ${tanhChild} * ${tanhChild});`;
+                }
+                case 'sigmoid': {
+                    const sigChild = `(1 / (1 + Math.exp(-${child})))`;
+                    return `${childGrad} += ${gradVar} * ${sigChild} * (1 - ${sigChild});`;
+                }
+                case 'relu':
+                    return `${childGrad} += ${gradVar} * (${child} > 0 ? 1 : 0);`;
+                case 'sin':
+                    return `${childGrad} += ${gradVar} * Math.cos(${child});`;
+                case 'cos':
+                    return `${childGrad} += ${gradVar} * (-Math.sin(${child}));`;
+                case 'tan': {
+                    const cosChild = `Math.cos(${child})`;
+                    return `${childGrad} += ${gradVar} / (${cosChild} * ${cosChild});`;
+                }
+                case 'asin':
+                    return `${childGrad} += ${gradVar} / Math.sqrt(1 - ${child} * ${child});`;
+                case 'acos':
+                    return `${childGrad} += ${gradVar} / (-Math.sqrt(1 - ${child} * ${child}));`;
+                case 'atan':
+                    return `${childGrad} += ${gradVar} / (1 + ${child} * ${child});`;
+                case 'neg':
+                    return `${childGrad} -= ${gradVar};`;
+                case 'abs':
+                    return `${childGrad} += ${gradVar} * (${child} >= 0 ? 1 : -1);`;
+                case 'square':
+                    return `${childGrad} += ${gradVar} * 2 * ${child};`;
+                case 'cube':
+                    return `${childGrad} += ${gradVar} * 3 * ${child} * ${child};`;
+                case 'reciprocal':
+                    return `${childGrad} -= ${gradVar} / (${child} * ${child});`;
+                case 'sign':
+                    return `${childGrad} += 0;`;
+                case 'softplus': {
+                    const expChild = `Math.exp(${child})`;
+                    return `${childGrad} += ${gradVar} * ${expChild} / (1 + ${expChild});`;
+                }
+                case 'floor':
+                case 'ceil':
+                case 'round':
+                    return `${childGrad} += 0;`;
+                case 'clamp': {
+                    const [min, max] = this._opConstants || [0, 1];
+                    return `${childGrad} += ${gradVar} * (${child} > ${min} && ${child} < ${max} ? 1 : 0);`;
+                }
+                default:
+                    return '';
+            }
+        }
+        // N-ary operations (6 inputs)
+        if (this.prev.length === 6 && this._op === 'eigenvalue_custom') {
+            const [g00, g01, g02, g11, g12, g22] = childGrads;
+            const [v00, v01, v02, v11, v12, v22] = childVars;
+            return `{
+        const grads = window.__eigenHelpers.applyEigenvalueGradients(
+          ${gradVar}, ${v00}, ${v01}, ${v02}, ${v11}, ${v12}, ${v22},
+          ${g00}, ${g01}, ${g02}, ${g11}, ${g12}, ${g22}
+        );
+        ${g00} = grads[0]; ${g01} = grads[1]; ${g02} = grads[2];
+        ${g11} = grads[3]; ${g12} = grads[4]; ${g22} = grads[5];
+      }`;
+        }
+        const [leftGrad, rightGrad] = childGrads;
+        const [left, right] = childVars;
+        switch (this._op) {
+            case '+':
+                return `${leftGrad} += ${gradVar}; ${rightGrad} += ${gradVar};`;
+            case '-':
+                return `${leftGrad} += ${gradVar}; ${rightGrad} -= ${gradVar};`;
+            case '*':
+                return `${leftGrad} += ${gradVar} * ${right}; ${rightGrad} += ${gradVar} * ${left};`;
+            case '/':
+                return `${leftGrad} += ${gradVar} / ${right}; ${rightGrad} -= ${gradVar} * ${left} / (${right} * ${right});`;
+            case 'powValue':
+                return `${leftGrad} += ${gradVar} * ${right} * Math.pow(${left}, ${right} - 1); ${rightGrad} += ${gradVar} * Math.pow(${left}, ${right}) * Math.log(${left});`;
+            case 'mod':
+                return `${leftGrad} += ${gradVar}; ${rightGrad} += 0;`;
+            case 'min':
+                return `${leftGrad} += ${gradVar} * (${left} < ${right} ? 1 : 0); ${rightGrad} += ${gradVar} * (${right} < ${left} ? 1 : 0);`;
+            case 'max':
+                return `${leftGrad} += ${gradVar} * (${left} > ${right} ? 1 : 0); ${rightGrad} += ${gradVar} * (${right} > ${left} ? 1 : 0);`;
+            default:
+                return '';
+        }
+    }
 }
-exports.Value = Value;

package/dist/ValueActivation.js

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

package/dist/ValueArithmetic.d.ts

@@ -23,4 +23,5 @@ export declare class ValueArithmetic {
     static sum(vals: Value[]): Value;
     static mean(vals: Value[]): Value;
     static neg(a: Value): Value;
+    static sign(a: Value): Value;
 }