gradient-script 0.1.0

package/dist/dsl/Simplify.js

@@ -0,0 +1,276 @@
+/**
+ * Expression simplification for GradientScript DSL
+ * Applies algebraic simplification rules
+ */
+import { ExpressionTransformer } from './ExpressionTransformer.js';
+/**
+ * Simplifier - applies algebraic simplification rules recursively
+ */
+class Simplifier extends ExpressionTransformer {
+    fixedPoint = false;
+    constructor(fixedPoint = false) {
+        super();
+        this.fixedPoint = fixedPoint;
+    }
+    visitBinaryOp(expr) {
+        const left = this.transform(expr.left);
+        const right = this.transform(expr.right);
+        const leftNum = isNumber(left) ? left.value : null;
+        const rightNum = isNumber(right) ? right.value : null;
+        // Constant folding
+        if (leftNum !== null && rightNum !== null) {
+            let result;
+            switch (expr.operator) {
+                case '+':
+                    result = leftNum + rightNum;
+                    break;
+                case '-':
+                    result = leftNum - rightNum;
+                    break;
+                case '*':
+                    result = leftNum * rightNum;
+                    break;
+                case '/':
+                    result = leftNum / rightNum;
+                    break;
+                case '^':
+                case '**':
+                    result = Math.pow(leftNum, rightNum);
+                    break;
+            }
+            return { kind: 'number', value: result };
+        }
+        // Addition rules
+        if (expr.operator === '+') {
+            if (leftNum === 0)
+                return right;
+            if (rightNum === 0)
+                return left;
+        }
+        // Subtraction rules
+        if (expr.operator === '-') {
+            if (rightNum === 0)
+                return left;
+            if (leftNum === 0) {
+                return { kind: 'unary', operator: '-', operand: right };
+            }
+            if (expressionsEqual(left, right)) {
+                return { kind: 'number', value: 0 };
+            }
+        }
+        // Multiplication rules
+        if (expr.operator === '*') {
+            if (leftNum === 0)
+                return { kind: 'number', value: 0 };
+            if (rightNum === 0)
+                return { kind: 'number', value: 0 };
+            if (leftNum === 1)
+                return right;
+            if (rightNum === 1)
+                return left;
+            // (x / x) * y → y
+            if (left.kind === 'binary' && left.operator === '/') {
+                if (expressionsEqual(left.left, left.right)) {
+                    return right;
+                }
+            }
+            // 0.5 * (a + a) → a
+            if (leftNum === 0.5 && right.kind === 'binary' && right.operator === '+') {
+                const { left: l1, right: r1 } = right;
+                if (expressionsEqual(l1, r1)) {
+                    return l1;
+                }
+            }
+            // 0.5 * (a*b + b*a) → a*b
+            if (leftNum === 0.5 && right.kind === 'binary' && right.operator === '+') {
+                const { left: l1, right: r1 } = right;
+                if (l1.kind === 'binary' && l1.operator === '*' &&
+                    r1.kind === 'binary' && r1.operator === '*') {
+                    if (expressionsEqual(l1.left, r1.right) && expressionsEqual(l1.right, r1.left)) {
+                        return l1;
+                    }
+                }
+            }
+            // c * (a*b + b*a) → 2*c*a*b
+            if (leftNum !== null && right.kind === 'binary' && right.operator === '+') {
+                const { left: l1, right: r1 } = right;
+                if (l1.kind === 'binary' && l1.operator === '*' &&
+                    r1.kind === 'binary' && r1.operator === '*') {
+                    if (expressionsEqual(l1.left, r1.right) && expressionsEqual(l1.right, r1.left)) {
+                        return {
+                            kind: 'binary',
+                            operator: '*',
+                            left: { kind: 'number', value: 2 * leftNum },
+                            right: l1
+                        };
+                    }
+                }
+            }
+        }
+        // Division rules
+        if (expr.operator === '/') {
+            if (leftNum === 0)
+                return { kind: 'number', value: 0 };
+            if (rightNum === 1)
+                return left;
+            if (expressionsEqual(left, right)) {
+                return { kind: 'number', value: 1 };
+            }
+        }
+        // Power rules
+        if (expr.operator === '^' || expr.operator === '**') {
+            if (rightNum === 0)
+                return { kind: 'number', value: 1 };
+            if (rightNum === 1)
+                return left;
+            if (leftNum === 0)
+                return { kind: 'number', value: 0 };
+            if (leftNum === 1)
+                return { kind: 'number', value: 1 };
+        }
+        return {
+            kind: 'binary',
+            operator: expr.operator,
+            left,
+            right
+        };
+    }
+    visitUnaryOp(expr) {
+        const operand = this.transform(expr.operand);
+        if (expr.operator === '-') {
+            // Double negation: --x = x
+            if (operand.kind === 'unary' && operand.operator === '-') {
+                return operand.operand;
+            }
+            // Negate number: -5 = -5
+            if (isNumber(operand)) {
+                return { kind: 'number', value: -operand.value };
+            }
+        }
+        if (expr.operator === '+') {
+            return operand;
+        }
+        return {
+            kind: 'unary',
+            operator: expr.operator,
+            operand
+        };
+    }
+    visitFunctionCall(expr) {
+        const args = expr.args.map(arg => this.transform(arg));
+        if (expr.name === 'sqrt' && args.length === 1) {
+            const arg = args[0];
+            if (isNumber(arg) && arg.value >= 0) {
+                return { kind: 'number', value: Math.sqrt(arg.value) };
+            }
+        }
+        if (expr.name === 'abs' && args.length === 1) {
+            const arg = args[0];
+            if (isNumber(arg)) {
+                return { kind: 'number', value: Math.abs(arg.value) };
+            }
+        }
+        return {
+            kind: 'call',
+            name: expr.name,
+            args
+        };
+    }
+    visitComponentAccess(expr) {
+        const object = this.transform(expr.object);
+        // (u + v).x -> u.x + v.x
+        if (object.kind === 'binary') {
+            return this.transform({
+                kind: 'binary',
+                operator: object.operator,
+                left: {
+                    kind: 'component',
+                    object: object.left,
+                    component: expr.component
+                },
+                right: {
+                    kind: 'component',
+                    object: object.right,
+                    component: expr.component
+                }
+            });
+        }
+        return {
+            kind: 'component',
+            object,
+            component: expr.component
+        };
+    }
+}
+/**
+ * Simplify an expression using algebraic rules
+ */
+export function simplify(expr) {
+    let current = expr;
+    let simplified;
+    do {
+        simplified = current;
+        current = new Simplifier(false).transform(simplified);
+    } while (!expressionsEqual(current, simplified));
+    return current;
+}
+/**
+ * Check if expression is a number literal
+ */
+function isNumber(expr) {
+    return expr.kind === 'number';
+}
+/**
+ * Check if two expressions are structurally equal
+ */
+function expressionsEqual(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'number':
+            return b.kind === 'number' && a.value === b.value;
+        case 'variable':
+            return b.kind === 'variable' && a.name === b.name;
+        case 'binary':
+            if (b.kind !== 'binary')
+                return false;
+            return a.operator === b.operator &&
+                expressionsEqual(a.left, b.left) &&
+                expressionsEqual(a.right, b.right);
+        case 'unary':
+            if (b.kind !== 'unary')
+                return false;
+            return a.operator === b.operator &&
+                expressionsEqual(a.operand, b.operand);
+        case 'call':
+            if (b.kind !== 'call')
+                return false;
+            return a.name === b.name &&
+                a.args.length === b.args.length &&
+                a.args.every((arg, i) => expressionsEqual(arg, b.args[i]));
+        case 'component':
+            if (b.kind !== 'component')
+                return false;
+            return a.component === b.component &&
+                expressionsEqual(a.object, b.object);
+    }
+}
+/**
+ * Simplify all gradients in a map
+ */
+export function simplifyGradients(gradients) {
+    const simplified = new Map();
+    for (const [key, value] of gradients.entries()) {
+        if ('components' in value) {
+            const simplifiedComps = new Map();
+            for (const [comp, expr] of value.components.entries()) {
+                simplifiedComps.set(comp, simplify(expr));
+            }
+            simplified.set(key, { components: simplifiedComps });
+        }
+        else {
+            simplified.set(key, simplify(value));
+        }
+    }
+    return simplified;
+}

package/dist/dsl/TypeInference.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Type inference for GradientScript DSL
+ * Infers types for all expressions and validates type correctness
+ */
+import { Program, FunctionDef, Expression, Statement } from './AST.js';
+import { Type, TypeEnv } from './Types.js';
+/**
+ * Type inference visitor
+ */
+export declare class TypeInferenceVisitor {
+    private env;
+    constructor(env: TypeEnv);
+    /**
+     * Infer type for an expression
+     */
+    inferExpression(expr: Expression): Type;
+    private inferNumber;
+    private inferVariable;
+    private inferBinary;
+    private inferUnary;
+    private inferCall;
+    private inferComponent;
+}
+/**
+ * Infer types for a statement
+ */
+export declare function inferStatement(stmt: Statement, env: TypeEnv): void;
+/**
+ * Infer types for a function
+ */
+export declare function inferFunction(func: FunctionDef): TypeEnv;
+/**
+ * Infer types for entire program
+ */
+export declare function inferProgram(program: Program): void;
+/**
+ * Convenience function to infer types
+ */
+export declare function inferTypes(program: Program): Program;

package/dist/dsl/TypeInference.js

@@ -0,0 +1,147 @@
+/**
+ * Type inference for GradientScript DSL
+ * Infers types for all expressions and validates type correctness
+ */
+import { Types, TypeEnv } from './Types.js';
+import { builtIns } from './BuiltIns.js';
+import { TypeError } from './Errors.js';
+/**
+ * Type inference visitor
+ */
+export class TypeInferenceVisitor {
+    env;
+    constructor(env) {
+        this.env = env;
+    }
+    /**
+     * Infer type for an expression
+     */
+    inferExpression(expr) {
+        switch (expr.kind) {
+            case 'number':
+                return this.inferNumber(expr);
+            case 'variable':
+                return this.inferVariable(expr);
+            case 'binary':
+                return this.inferBinary(expr);
+            case 'unary':
+                return this.inferUnary(expr);
+            case 'call':
+                return this.inferCall(expr);
+            case 'component':
+                return this.inferComponent(expr);
+        }
+    }
+    inferNumber(expr) {
+        const type = Types.scalar();
+        expr.type = type;
+        return type;
+    }
+    inferVariable(expr) {
+        const type = this.env.getOrThrow(expr.name);
+        expr.type = type;
+        return type;
+    }
+    inferBinary(expr) {
+        const leftType = this.inferExpression(expr.left);
+        const rightType = this.inferExpression(expr.right);
+        if (!Types.compatible(leftType, rightType)) {
+            throw new TypeError(`Type mismatch in binary operation`, expr.operator, Types.toString(leftType), Types.toString(rightType));
+        }
+        const resultType = Types.binaryResultType(leftType, rightType, expr.operator);
+        expr.type = resultType;
+        return resultType;
+    }
+    inferUnary(expr) {
+        const operandType = this.inferExpression(expr.operand);
+        const resultType = Types.unaryResultType(operandType, expr.operator);
+        expr.type = resultType;
+        return resultType;
+    }
+    inferCall(expr) {
+        // Infer argument types
+        const argTypes = expr.args.map(arg => this.inferExpression(arg));
+        // Look up built-in function
+        const signature = builtIns.lookup(expr.name, argTypes);
+        if (!signature) {
+            if (builtIns.isBuiltIn(expr.name)) {
+                const overloads = builtIns.getOverloads(expr.name);
+                const expectedSigs = overloads.map(sig => `${sig.name}(${sig.params.map(p => Types.toString(p)).join(', ')})`).join(' or ');
+                const actualSig = `${expr.name}(${argTypes.map(t => Types.toString(t)).join(', ')})`;
+                throw new TypeError(`No matching overload. Expected: ${expectedSigs}`, actualSig);
+            }
+            else {
+                throw new TypeError(`Unknown function`, expr.name);
+            }
+        }
+        expr.type = signature.returnType;
+        return signature.returnType;
+    }
+    inferComponent(expr) {
+        const objectType = this.inferExpression(expr.object);
+        if (!Types.isStruct(objectType)) {
+            throw new TypeError(`Cannot access component of scalar type`, expr.component, 'struct', 'scalar');
+        }
+        if (!objectType.components.includes(expr.component)) {
+            throw new TypeError(`Component does not exist. Available: ${objectType.components.join(', ')}`, expr.component, objectType.components.join('|'), expr.component);
+        }
+        const resultType = Types.scalar();
+        expr.type = resultType;
+        return resultType;
+    }
+}
+/**
+ * Infer types for a statement
+ */
+export function inferStatement(stmt, env) {
+    if (stmt.kind === 'assignment') {
+        const visitor = new TypeInferenceVisitor(env);
+        const exprType = visitor.inferExpression(stmt.expression);
+        // Add variable to environment
+        env.set(stmt.variable, exprType);
+    }
+}
+/**
+ * Infer types for a function
+ */
+export function inferFunction(func) {
+    const env = new TypeEnv();
+    // Add parameters to environment
+    for (const param of func.parameters) {
+        let paramType;
+        if (param.paramType) {
+            // Explicit type annotation
+            paramType = Types.struct(param.paramType.components);
+        }
+        else {
+            // No annotation - assume scalar for now
+            // (could be inferred from usage later)
+            paramType = Types.scalar();
+        }
+        env.set(param.name, paramType);
+    }
+    // Infer types for statements
+    for (const stmt of func.body) {
+        inferStatement(stmt, env);
+    }
+    // Infer return type
+    const visitor = new TypeInferenceVisitor(env);
+    const returnType = visitor.inferExpression(func.returnExpr);
+    func.type = returnType;
+    return env;
+}
+/**
+ * Infer types for entire program
+ */
+export function inferProgram(program) {
+    for (const func of program.functions) {
+        inferFunction(func);
+    }
+}
+/**
+ * Convenience function to infer types
+ */
+export function inferTypes(program) {
+    inferProgram(program);
+    return program;
+}

package/dist/dsl/Types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Type system for GradientScript DSL
+ * Handles scalar vs structured types and type inference
+ */
+/**
+ * Represents a type in the DSL
+ */
+export type Type = ScalarType | StructType;
+/**
+ * Scalar type (numbers)
+ */
+export interface ScalarType {
+    kind: 'scalar';
+}
+/**
+ * Structured type with named components
+ * e.g., {x, y} or {x, y, z}
+ */
+export interface StructType {
+    kind: 'struct';
+    components: string[];
+}
+/**
+ * Type utilities
+ */
+export declare const Types: {
+    scalar(): ScalarType;
+    struct(components: string[]): StructType;
+    vec2(): StructType;
+    vec3(): StructType;
+    isScalar(type: Type): type is ScalarType;
+    isStruct(type: Type): type is StructType;
+    equals(a: Type, b: Type): boolean;
+    toString(type: Type): string;
+    /**
+     * Check if two types are compatible for binary operations
+     */
+    compatible(a: Type, b: Type): boolean;
+    /**
+     * Result type of binary operation
+     */
+    binaryResultType(a: Type, b: Type, op: string): Type;
+    /**
+     * Result type of unary operation
+     */
+    unaryResultType(type: Type, op: string): Type;
+};
+/**
+ * Type environment for tracking variable types
+ */
+export declare class TypeEnv {
+    private types;
+    set(name: string, type: Type): void;
+    get(name: string): Type | undefined;
+    has(name: string): boolean;
+    clone(): TypeEnv;
+    getOrThrow(name: string): Type;
+}

package/dist/dsl/Types.js

@@ -0,0 +1,114 @@
+/**
+ * Type system for GradientScript DSL
+ * Handles scalar vs structured types and type inference
+ */
+/**
+ * Type utilities
+ */
+export const Types = {
+    scalar() {
+        return { kind: 'scalar' };
+    },
+    struct(components) {
+        return { kind: 'struct', components };
+    },
+    vec2() {
+        return { kind: 'struct', components: ['x', 'y'] };
+    },
+    vec3() {
+        return { kind: 'struct', components: ['x', 'y', 'z'] };
+    },
+    isScalar(type) {
+        return type.kind === 'scalar';
+    },
+    isStruct(type) {
+        return type.kind === 'struct';
+    },
+    equals(a, b) {
+        if (a.kind !== b.kind)
+            return false;
+        if (a.kind === 'scalar')
+            return true;
+        const aStruct = a;
+        const bStruct = b;
+        if (aStruct.components.length !== bStruct.components.length)
+            return false;
+        return aStruct.components.every((comp, i) => comp === bStruct.components[i]);
+    },
+    toString(type) {
+        if (type.kind === 'scalar')
+            return 'scalar';
+        return `{${type.components.join(', ')}}`;
+    },
+    /**
+     * Check if two types are compatible for binary operations
+     */
+    compatible(a, b) {
+        // scalar + scalar = ok
+        if (a.kind === 'scalar' && b.kind === 'scalar')
+            return true;
+        // struct + struct = ok if same structure
+        if (a.kind === 'struct' && b.kind === 'struct') {
+            return Types.equals(a, b);
+        }
+        // scalar + struct = ok (broadcasting)
+        if (a.kind === 'scalar' || b.kind === 'scalar')
+            return true;
+        return false;
+    },
+    /**
+     * Result type of binary operation
+     */
+    binaryResultType(a, b, op) {
+        // scalar op scalar = scalar
+        if (a.kind === 'scalar' && b.kind === 'scalar') {
+            return Types.scalar();
+        }
+        // struct op struct = struct (element-wise)
+        if (a.kind === 'struct' && b.kind === 'struct') {
+            if (!Types.equals(a, b)) {
+                throw new Error(`Type mismatch: cannot perform ${op} on ${Types.toString(a)} and ${Types.toString(b)}`);
+            }
+            return a;
+        }
+        // scalar op struct = struct (broadcasting)
+        if (a.kind === 'scalar' && b.kind === 'struct')
+            return b;
+        if (a.kind === 'struct' && b.kind === 'scalar')
+            return a;
+        throw new Error(`Invalid types for ${op}: ${Types.toString(a)} and ${Types.toString(b)}`);
+    },
+    /**
+     * Result type of unary operation
+     */
+    unaryResultType(type, op) {
+        return type; // Unary ops preserve type
+    }
+};
+/**
+ * Type environment for tracking variable types
+ */
+export class TypeEnv {
+    types = new Map();
+    set(name, type) {
+        this.types.set(name, type);
+    }
+    get(name) {
+        return this.types.get(name);
+    }
+    has(name) {
+        return this.types.has(name);
+    }
+    clone() {
+        const env = new TypeEnv();
+        env.types = new Map(this.types);
+        return env;
+    }
+    getOrThrow(name) {
+        const type = this.get(name);
+        if (!type) {
+            throw new Error(`Variable '${name}' is not defined`);
+        }
+        return type;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GradientScript - Symbolic differentiation for structured types
+ *
+ * This library provides automatic differentiation for functions with
+ * structured types (vectors, custom structures).
+ */
+export { parse } from './dsl/Parser.js';
+export { inferFunction } from './dsl/TypeInference.js';
+export { computeFunctionGradients } from './dsl/Differentiation.js';
+export { generateComplete, generateGradientFunction, type CodeGenOptions } from './dsl/CodeGen.js';
+export type { Expression, FunctionDef, Program, Parameter, Assignment } from './dsl/AST.js';
+export type { Type, ScalarType, StructType, TypeEnv } from './dsl/Types.js';
+export type { GradCheckResult, GradCheckError } from './dsl/GradientChecker.js';

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * GradientScript - Symbolic differentiation for structured types
+ *
+ * This library provides automatic differentiation for functions with
+ * structured types (vectors, custom structures).
+ */
+// Core API
+export { parse } from './dsl/Parser.js';
+export { inferFunction } from './dsl/TypeInference.js';
+export { computeFunctionGradients } from './dsl/Differentiation.js';
+export { generateComplete, generateGradientFunction } from './dsl/CodeGen.js';