gradient-script 0.1.0 → 0.3.0

package/dist/symbolic/Parser.js

@@ -1,329 +0,0 @@
-/**
- * Expression parser for symbolic gradient generation.
- * Parses operator-overloaded mathematical expressions into AST.
- * @internal
- */
-import { NumberNode, VariableNode, BinaryOpNode, UnaryOpNode, FunctionCallNode, VectorAccessNode, VectorConstructorNode } from './AST';
-/**
- * Token types for lexical analysis
- */
-var TokenType;
-(function (TokenType) {
-    TokenType[TokenType["NUMBER"] = 0] = "NUMBER";
-    TokenType[TokenType["IDENTIFIER"] = 1] = "IDENTIFIER";
-    TokenType[TokenType["PLUS"] = 2] = "PLUS";
-    TokenType[TokenType["MINUS"] = 3] = "MINUS";
-    TokenType[TokenType["MULTIPLY"] = 4] = "MULTIPLY";
-    TokenType[TokenType["DIVIDE"] = 5] = "DIVIDE";
-    TokenType[TokenType["POWER"] = 6] = "POWER";
-    TokenType[TokenType["LPAREN"] = 7] = "LPAREN";
-    TokenType[TokenType["RPAREN"] = 8] = "RPAREN";
-    TokenType[TokenType["DOT"] = 9] = "DOT";
-    TokenType[TokenType["COMMA"] = 10] = "COMMA";
-    TokenType[TokenType["EQUALS"] = 11] = "EQUALS";
-    TokenType[TokenType["SEMICOLON"] = 12] = "SEMICOLON";
-    TokenType[TokenType["NEWLINE"] = 13] = "NEWLINE";
-    TokenType[TokenType["EOF"] = 14] = "EOF";
-})(TokenType || (TokenType = {}));
-/**
- * Lexer: converts text into tokens
- */
-class Lexer {
-    pos = 0;
-    text;
-    constructor(text) {
-        this.text = text;
-    }
-    peek(offset = 0) {
-        const pos = this.pos + offset;
-        return pos < this.text.length ? this.text[pos] : '\0';
-    }
-    advance() {
-        const ch = this.peek();
-        this.pos++;
-        return ch;
-    }
-    skipWhitespace() {
-        while (this.peek() === ' ' || this.peek() === '\t' || this.peek() === '\r') {
-            this.advance();
-        }
-    }
-    readNumber() {
-        const start = this.pos;
-        let numStr = '';
-        while (/[0-9.]/.test(this.peek())) {
-            numStr += this.advance();
-        }
-        return { type: TokenType.NUMBER, value: parseFloat(numStr), pos: start };
-    }
-    readIdentifier() {
-        const start = this.pos;
-        let id = '';
-        while (/[a-zA-Z0-9_]/.test(this.peek())) {
-            id += this.advance();
-        }
-        return { type: TokenType.IDENTIFIER, value: id, pos: start };
-    }
-    nextToken() {
-        this.skipWhitespace();
-        const ch = this.peek();
-        const pos = this.pos;
-        if (ch === '\0') {
-            return { type: TokenType.EOF, value: '', pos };
-        }
-        if (ch === '\n') {
-            this.advance();
-            return { type: TokenType.NEWLINE, value: '\n', pos };
-        }
-        if (/[0-9]/.test(ch)) {
-            return this.readNumber();
-        }
-        if (/[a-zA-Z_]/.test(ch)) {
-            return this.readIdentifier();
-        }
-        // Single-character tokens
-        this.advance();
-        switch (ch) {
-            case '+': return { type: TokenType.PLUS, value: '+', pos };
-            case '-': return { type: TokenType.MINUS, value: '-', pos };
-            case '*':
-                // Check for **
-                if (this.peek() === '*') {
-                    this.advance();
-                    return { type: TokenType.POWER, value: '**', pos };
-                }
-                return { type: TokenType.MULTIPLY, value: '*', pos };
-            case '/': return { type: TokenType.DIVIDE, value: '/', pos };
-            case '(': return { type: TokenType.LPAREN, value: '(', pos };
-            case ')': return { type: TokenType.RPAREN, value: ')', pos };
-            case '.': return { type: TokenType.DOT, value: '.', pos };
-            case ',': return { type: TokenType.COMMA, value: ',', pos };
-            case '=': return { type: TokenType.EQUALS, value: '=', pos };
-            case ';': return { type: TokenType.SEMICOLON, value: ';', pos };
-            default:
-                throw new Error(`Unexpected character '${ch}' at position ${pos}`);
-        }
-    }
-    tokenize() {
-        const tokens = [];
-        let token;
-        do {
-            token = this.nextToken();
-            // Skip newlines and semicolons (treat as statement separators)
-            if (token.type !== TokenType.NEWLINE && token.type !== TokenType.SEMICOLON) {
-                tokens.push(token);
-            }
-        } while (token.type !== TokenType.EOF);
-        return tokens;
-    }
-}
-/**
- * Parser: converts tokens into AST
- * Grammar (precedence from lowest to highest):
- *   assignment   → IDENTIFIER '=' expression
- *   expression   → term (('+' | '-') term)*
- *   term         → factor (('*' | '/') factor)*
- *   factor       → power
- *   power        → postfix ('**' postfix)*
- *   postfix      → primary ('.' IDENTIFIER)*
- *   primary      → NUMBER | IDENTIFIER | function_call | vector_constructor | '(' expression ')' | ('+' | '-') primary
- *   function_call → IDENTIFIER '(' arg_list? ')'
- *   vector_constructor → ('Vec2' | 'Vec3') '(' arg_list ')'
- *   arg_list     → expression (',' expression)*
- */
-export class Parser {
-    tokens;
-    current = 0;
-    constructor(text) {
-        const lexer = new Lexer(text);
-        this.tokens = lexer.tokenize();
-    }
-    peek(offset = 0) {
-        const idx = this.current + offset;
-        return idx < this.tokens.length ? this.tokens[idx] : this.tokens[this.tokens.length - 1];
-    }
-    advance() {
-        const token = this.peek();
-        if (token.type !== TokenType.EOF) {
-            this.current++;
-        }
-        return token;
-    }
-    expect(type, message) {
-        const token = this.peek();
-        if (token.type !== type) {
-            throw new Error(message || `Expected token type ${TokenType[type]}, got ${TokenType[token.type]} at position ${token.pos}`);
-        }
-        return this.advance();
-    }
-    /**
-     * Parse a complete program
-     */
-    parseProgram() {
-        const assignments = [];
-        let outputVar = '';
-        while (this.peek().type !== TokenType.EOF) {
-            // Check if this is an assignment
-            if (this.peek().type === TokenType.IDENTIFIER && this.peek(1).type === TokenType.EQUALS) {
-                const varName = this.peek().value;
-                this.advance(); // identifier
-                this.advance(); // equals
-                const expression = this.parseExpression();
-                assignments.push({ variable: varName, expression });
-                // Track the last assigned variable as potential output
-                outputVar = varName;
-            }
-            else {
-                // Standalone expression - treat as output
-                const expression = this.parseExpression();
-                // Generate a temporary output variable
-                const tempVar = `_output${assignments.length}`;
-                assignments.push({ variable: tempVar, expression });
-                outputVar = tempVar;
-            }
-        }
-        // Look for explicit "output" variable
-        const outputAssignment = assignments.find(a => a.variable === 'output');
-        if (outputAssignment) {
-            outputVar = 'output';
-        }
-        return { assignments, output: outputVar };
-    }
-    /**
-     * Parse an expression
-     */
-    parseExpression() {
-        return this.parseTerm();
-    }
-    /**
-     * Parse term (addition/subtraction)
-     */
-    parseTerm() {
-        let left = this.parseFactor();
-        while (this.peek().type === TokenType.PLUS || this.peek().type === TokenType.MINUS) {
-            const op = this.advance().value;
-            const right = this.parseFactor();
-            left = new BinaryOpNode(op, left, right);
-        }
-        return left;
-    }
-    /**
-     * Parse factor (multiplication/division)
-     */
-    parseFactor() {
-        let left = this.parsePower();
-        while (this.peek().type === TokenType.MULTIPLY || this.peek().type === TokenType.DIVIDE) {
-            const op = this.advance().value;
-            const right = this.parsePower();
-            left = new BinaryOpNode(op, left, right);
-        }
-        return left;
-    }
-    /**
-     * Parse power (exponentiation)
-     */
-    parsePower() {
-        let left = this.parsePostfix();
-        // Right-associative: 2**3**2 = 2**(3**2) = 512
-        if (this.peek().type === TokenType.POWER) {
-            this.advance();
-            const right = this.parsePower(); // Recursive for right-associativity
-            left = new BinaryOpNode('**', left, right);
-        }
-        return left;
-    }
-    /**
-     * Parse postfix (member access like v.x)
-     */
-    parsePostfix() {
-        let node = this.parsePrimary();
-        while (this.peek().type === TokenType.DOT) {
-            this.advance(); // consume '.'
-            const member = this.expect(TokenType.IDENTIFIER, 'Expected component name after "."');
-            const memberName = member.value;
-            // Check if it's a vector component or method
-            if (memberName === 'x' || memberName === 'y' || memberName === 'z') {
-                node = new VectorAccessNode(node, memberName);
-            }
-            else if (memberName === 'magnitude' || memberName === 'sqrMagnitude' || memberName === 'normalized') {
-                // These are property accesses that look like functions
-                node = new FunctionCallNode(memberName, [node]);
-            }
-            else {
-                // Method call (e.g., v.dot(u))
-                this.expect(TokenType.LPAREN);
-                const args = [node]; // First arg is the object itself
-                args.push(...this.parseArgList());
-                this.expect(TokenType.RPAREN);
-                node = new FunctionCallNode(memberName, args);
-            }
-        }
-        return node;
-    }
-    /**
-     * Parse primary expression
-     */
-    parsePrimary() {
-        const token = this.peek();
-        // Number literal
-        if (token.type === TokenType.NUMBER) {
-            this.advance();
-            return new NumberNode(token.value);
-        }
-        // Unary + or -
-        if (token.type === TokenType.PLUS || token.type === TokenType.MINUS) {
-            const op = this.advance().value;
-            const operand = this.parsePrimary();
-            return new UnaryOpNode(op, operand);
-        }
-        // Parenthesized expression
-        if (token.type === TokenType.LPAREN) {
-            this.advance();
-            const expr = this.parseExpression();
-            this.expect(TokenType.RPAREN, 'Expected closing parenthesis');
-            return expr;
-        }
-        // Identifier (variable, function call, or vector constructor)
-        if (token.type === TokenType.IDENTIFIER) {
-            const name = token.value;
-            this.advance();
-            // Check for function call or vector constructor
-            if (this.peek().type === TokenType.LPAREN) {
-                this.advance(); // consume '('
-                const args = this.parseArgList();
-                this.expect(TokenType.RPAREN, 'Expected closing parenthesis in function call');
-                // Vector constructor
-                if (name === 'Vec2' || name === 'Vec3') {
-                    return new VectorConstructorNode(name, args);
-                }
-                // Function call
-                return new FunctionCallNode(name, args);
-            }
-            // Just a variable reference
-            return new VariableNode(name);
-        }
-        throw new Error(`Unexpected token ${TokenType[token.type]} at position ${token.pos}`);
-    }
-    /**
-     * Parse function argument list
-     */
-    parseArgList() {
-        const args = [];
-        if (this.peek().type === TokenType.RPAREN) {
-            return args; // Empty arg list
-        }
-        args.push(this.parseExpression());
-        while (this.peek().type === TokenType.COMMA) {
-            this.advance(); // consume comma
-            args.push(this.parseExpression());
-        }
-        return args;
-    }
-}
-/**
- * Parse a mathematical expression string into an AST
- */
-export function parse(text) {
-    const parser = new Parser(text);
-    return parser.parseProgram();
-}

package/dist/symbolic/Simplify.d.ts

@@ -1,10 +0,0 @@
-/**
- * Expression simplification for symbolic gradients.
- * Applies algebraic simplification rules to make formulas more readable.
- * @internal
- */
-import { ASTNode } from './AST';
-/**
- * Simplify an AST node
- */
-export declare function simplify(node: ASTNode): ASTNode;

package/dist/symbolic/Simplify.js

@@ -1,244 +0,0 @@
-/**
- * Expression simplification for symbolic gradients.
- * Applies algebraic simplification rules to make formulas more readable.
- * @internal
- */
-import { NumberNode, BinaryOpNode, UnaryOpNode, FunctionCallNode, VectorAccessNode, VectorConstructorNode } from './AST';
-/**
- * Simplification visitor
- */
-class SimplificationVisitor {
-    visitNumber(node) {
-        return node;
-    }
-    visitVariable(node) {
-        return node;
-    }
-    visitUnaryOp(node) {
-        const operand = node.operand.accept(this);
-        // Simplify -(-x) = x
-        if (node.op === '-' && operand.type === 'UnaryOp') {
-            const unary = operand;
-            if (unary.op === '-') {
-                return unary.operand;
-            }
-        }
-        // Simplify -(0) = 0
-        if (node.op === '-' && operand.type === 'Number') {
-            return new NumberNode(-operand.value);
-        }
-        // Simplify +(x) = x
-        if (node.op === '+') {
-            return operand;
-        }
-        return new UnaryOpNode(node.op, operand);
-    }
-    visitBinaryOp(node) {
-        // First simplify children
-        const left = node.left.accept(this);
-        const right = node.right.accept(this);
-        // Get numeric values if both are numbers
-        const leftNum = left.type === 'Number' ? left.value : null;
-        const rightNum = right.type === 'Number' ? right.value : null;
-        // Constant folding
-        if (leftNum !== null && rightNum !== null) {
-            switch (node.op) {
-                case '+': return new NumberNode(leftNum + rightNum);
-                case '-': return new NumberNode(leftNum - rightNum);
-                case '*': return new NumberNode(leftNum * rightNum);
-                case '/': return new NumberNode(leftNum / rightNum);
-                case '**': return new NumberNode(Math.pow(leftNum, rightNum));
-            }
-        }
-        // Addition simplifications
-        if (node.op === '+') {
-            // 0 + x = x
-            if (leftNum === 0)
-                return right;
-            // x + 0 = x
-            if (rightNum === 0)
-                return left;
-            // x + x = 2*x
-            if (nodesEqual(left, right)) {
-                return new BinaryOpNode('*', new NumberNode(2), left);
-            }
-        }
-        // Subtraction simplifications
-        if (node.op === '-') {
-            // x - 0 = x
-            if (rightNum === 0)
-                return left;
-            // 0 - x = -x
-            if (leftNum === 0)
-                return new UnaryOpNode('-', right);
-            // x - x = 0
-            if (nodesEqual(left, right)) {
-                return new NumberNode(0);
-            }
-        }
-        // Multiplication simplifications
-        if (node.op === '*') {
-            // 0 * x = 0
-            if (leftNum === 0 || rightNum === 0)
-                return new NumberNode(0);
-            // 1 * x = x
-            if (leftNum === 1)
-                return right;
-            // x * 1 = x
-            if (rightNum === 1)
-                return left;
-            // -1 * x = -x
-            if (leftNum === -1)
-                return new UnaryOpNode('-', right);
-            // x * -1 = -x
-            if (rightNum === -1)
-                return new UnaryOpNode('-', left);
-            // x * x = x^2
-            if (nodesEqual(left, right)) {
-                return new BinaryOpNode('**', left, new NumberNode(2));
-            }
-        }
-        // Division simplifications
-        if (node.op === '/') {
-            // 0 / x = 0
-            if (leftNum === 0)
-                return new NumberNode(0);
-            // x / 1 = x
-            if (rightNum === 1)
-                return left;
-            // x / x = 1
-            if (nodesEqual(left, right))
-                return new NumberNode(1);
-        }
-        // Power simplifications
-        if (node.op === '**') {
-            // x^0 = 1
-            if (rightNum === 0)
-                return new NumberNode(1);
-            // x^1 = x
-            if (rightNum === 1)
-                return left;
-            // 0^x = 0 (for x > 0)
-            if (leftNum === 0)
-                return new NumberNode(0);
-            // 1^x = 1
-            if (leftNum === 1)
-                return new NumberNode(1);
-        }
-        return new BinaryOpNode(node.op, left, right);
-    }
-    visitFunctionCall(node) {
-        const args = node.args.map(arg => arg.accept(this));
-        // Check for constant arguments
-        if (args.length === 1 && args[0].type === 'Number') {
-            const value = args[0].value;
-            switch (node.name) {
-                case 'sin': return new NumberNode(Math.sin(value));
-                case 'cos': return new NumberNode(Math.cos(value));
-                case 'tan': return new NumberNode(Math.tan(value));
-                case 'exp': return new NumberNode(Math.exp(value));
-                case 'log':
-                case 'ln': return new NumberNode(Math.log(value));
-                case 'sqrt': return new NumberNode(Math.sqrt(value));
-                case 'abs': return new NumberNode(Math.abs(value));
-                case 'sign': return new NumberNode(Math.sign(value));
-                case 'floor': return new NumberNode(Math.floor(value));
-                case 'ceil': return new NumberNode(Math.ceil(value));
-                case 'round': return new NumberNode(Math.round(value));
-                case 'asin': return new NumberNode(Math.asin(value));
-                case 'acos': return new NumberNode(Math.acos(value));
-                case 'atan': return new NumberNode(Math.atan(value));
-                case 'sinh': return new NumberNode(Math.sinh(value));
-                case 'cosh': return new NumberNode(Math.cosh(value));
-                case 'tanh': return new NumberNode(Math.tanh(value));
-            }
-        }
-        // Two-argument functions
-        if (args.length === 2 && args[0].type === 'Number' && args[1].type === 'Number') {
-            const val1 = args[0].value;
-            const val2 = args[1].value;
-            switch (node.name) {
-                case 'pow': return new NumberNode(Math.pow(val1, val2));
-                case 'min': return new NumberNode(Math.min(val1, val2));
-                case 'max': return new NumberNode(Math.max(val1, val2));
-            }
-        }
-        // Special simplifications
-        // exp(0) = 1
-        if (node.name === 'exp' && args[0].type === 'Number' && args[0].value === 0) {
-            return new NumberNode(1);
-        }
-        // log(1) = 0
-        if ((node.name === 'log' || node.name === 'ln') && args[0].type === 'Number' && args[0].value === 1) {
-            return new NumberNode(0);
-        }
-        // sqrt(1) = 1
-        if (node.name === 'sqrt' && args[0].type === 'Number' && args[0].value === 1) {
-            return new NumberNode(1);
-        }
-        return new FunctionCallNode(node.name, args);
-    }
-    visitVectorAccess(node) {
-        const vector = node.vector.accept(this);
-        return new VectorAccessNode(vector, node.component);
-    }
-    visitVectorConstructor(node) {
-        const components = node.components.map(c => c.accept(this));
-        return new VectorConstructorNode(node.vectorType, components);
-    }
-}
-/**
- * Check if two AST nodes are structurally equal
- */
-function nodesEqual(a, b) {
-    if (a.type !== b.type)
-        return false;
-    if (a.type === 'Number' && b.type === 'Number') {
-        return a.value === b.value;
-    }
-    if (a.type === 'Variable' && b.type === 'Variable') {
-        return a.name === b.name;
-    }
-    if (a.type === 'UnaryOp' && b.type === 'UnaryOp') {
-        const aUnary = a;
-        const bUnary = b;
-        return aUnary.op === bUnary.op && nodesEqual(aUnary.operand, bUnary.operand);
-    }
-    if (a.type === 'BinaryOp' && b.type === 'BinaryOp') {
-        const aBinary = a;
-        const bBinary = b;
-        return aBinary.op === bBinary.op &&
-            nodesEqual(aBinary.left, bBinary.left) &&
-            nodesEqual(aBinary.right, bBinary.right);
-    }
-    if (a.type === 'FunctionCall' && b.type === 'FunctionCall') {
-        const aFunc = a;
-        const bFunc = b;
-        return aFunc.name === bFunc.name &&
-            aFunc.args.length === bFunc.args.length &&
-            aFunc.args.every((arg, i) => nodesEqual(arg, bFunc.args[i]));
-    }
-    if (a.type === 'VectorAccess' && b.type === 'VectorAccess') {
-        const aVec = a;
-        const bVec = b;
-        return aVec.component === bVec.component && nodesEqual(aVec.vector, bVec.vector);
-    }
-    return false;
-}
-/**
- * Simplify an AST node
- */
-export function simplify(node) {
-    const visitor = new SimplificationVisitor();
-    let current = node;
-    let previous;
-    // Keep simplifying until we reach a fixed point
-    let iterations = 0;
-    const maxIterations = 10;
-    do {
-        previous = current;
-        current = current.accept(visitor);
-        iterations++;
-    } while (iterations < maxIterations && !nodesEqual(current, previous));
-    return current;
-}

package/dist/symbolic/SymbolicDiff.d.ts

@@ -1,35 +0,0 @@
-/**
- * Symbolic differentiation engine.
- * Applies differentiation rules to AST and generates symbolic gradient expressions.
- * @internal
- */
-import { ASTNode, ASTVisitor, NumberNode, VariableNode, BinaryOpNode, UnaryOpNode, FunctionCallNode, VectorAccessNode, VectorConstructorNode, Program } from './AST';
-/**
- * Differentiate an AST node with respect to a variable
- */
-export declare class DifferentiationVisitor implements ASTVisitor<ASTNode> {
-    private wrt;
-    constructor(wrt: string);
-    visitNumber(node: NumberNode): ASTNode;
-    visitVariable(node: VariableNode): ASTNode;
-    visitUnaryOp(node: UnaryOpNode): ASTNode;
-    visitBinaryOp(node: BinaryOpNode): ASTNode;
-    visitFunctionCall(node: FunctionCallNode): ASTNode;
-    visitVectorAccess(node: VectorAccessNode): ASTNode;
-    visitVectorConstructor(node: VectorConstructorNode): ASTNode;
-}
-/**
- * Differentiate an AST node with respect to a variable
- */
-export declare function differentiate(node: ASTNode, wrt: string): ASTNode;
-/**
- * Compute all gradients for a program
- */
-export interface GradientResult {
-    variable: string;
-    gradient: ASTNode;
-}
-/**
- * Compute gradients of output w.r.t. all parameters
- */
-export declare function computeGradients(program: Program, parameters: string[]): Map<string, ASTNode>;