@cortex-js/compute-engine 0.33.0 → 0.35.0

package/dist/types/compute-engine/boxed-expression/solve-linear-system.d.ts

@@ -0,0 +1,60 @@
+/* 0.35.0 */
+/**
+ * Solve a system of linear equations.
+ *
+ * @param equations - Array of BoxedExpression representing equations (Equal expressions)
+ * @param variables - Array of variable names to solve for
+ * @returns Object mapping variable names to their solutions, or null if unsolvable
+ *
+ * For under-determined systems (fewer equations than variables), returns
+ * parametric solutions where free variables appear in the expressions.
+ *
+ * @example
+ * ```typescript
+ * // Unique solution
+ * const e = ce.parse('\\begin{cases}x+y=70\\\\2x-4y=80\\end{cases}');
+ * const result = e.solve(['x', 'y']);
+ * // result = { x: BoxedExpression(60), y: BoxedExpression(10) }
+ *
+ * // Parametric solution (under-determined)
+ * const e2 = ce.parse('\\begin{cases}x+y=5\\end{cases}');
+ * const result2 = e2.solve(['x', 'y']);
+ * // result2 = { x: 5 - y, y: y }
+ * ```
+ */
+export declare function solveLinearSystem(equations: BoxedExpression[], variables: string[]): Record<string, BoxedExpression> | null;
+/**
+ * Solve a system of polynomial equations that may be non-linear.
+ * Currently supports:
+ * 1. Product + sum pattern: xy = p, x + y = s (2 equations, 2 variables)
+ * 2. Substitution-reducible: one equation is linear in one variable
+ *
+ * @param equations - Array of BoxedExpression representing equations (Equal expressions)
+ * @param variables - Array of variable names to solve for
+ * @returns Array of solution objects, or null if unsolvable
+ *
+ * @example
+ * ```typescript
+ * // Product + sum pattern
+ * const e = ce.parse('\\begin{cases}xy=6\\\\x+y=5\\end{cases}');
+ * const result = e.solve(['x', 'y']);
+ * // result = [{ x: 2, y: 3 }, { x: 3, y: 2 }]
+ * ```
+ */
+export declare function solvePolynomialSystem(equations: BoxedExpression[], variables: string[]): Array<Record<string, BoxedExpression>> | null;
+/**
+ * Solve a system of linear inequalities in 2 variables.
+ * Returns the vertices of the feasible region (convex polygon).
+ *
+ * @param inequalities - Array of BoxedExpression representing inequalities
+ * @param variables - Array of exactly 2 variable names
+ * @returns Array of vertex coordinate objects, or null if unsolvable/unbounded
+ *
+ * @example
+ * ```typescript
+ * const e = ce.parse('\\begin{cases}x+y\\leq 10\\\\x\\geq 0\\\\y\\geq 0\\end{cases}');
+ * const result = e.solve(['x', 'y']);
+ * // result = [{ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 0, y: 10 }]
+ * ```
+ */
+export declare function solveLinearInequalitySystem(inequalities: BoxedExpression[], variables: string[]): Array<Record<string, BoxedExpression>> | null;

package/dist/types/compute-engine/boxed-expression/solve.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality

package/dist/types/compute-engine/boxed-expression/terms.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare class Terms {
     private engine;
     private terms;

package/dist/types/compute-engine/boxed-expression/trigonometry.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 /** Assuming x in an expression in radians, convert to current angular unit. */
 export declare function radiansToAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
 export declare function evalTrig(name: string, op: BoxedExpression | undefined): BoxedExpression | undefined;

package/dist/types/compute-engine/boxed-expression/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 import { Type } from '../../common/type/types';
 import { NumericValue } from '../numeric-value/types';
 /**

package/dist/types/compute-engine/boxed-expression/validate.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 import type { BoxedExpression, ComputeEngine } from '../global-types';
 /**
  * Check that the number of arguments is as expected.

package/dist/types/compute-engine/collection-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 /** If a collection has fewer than this many elements, eagerly evaluate it.
  *
  * For example, evaluate the Union of two sets with 10 elements each will

package/dist/types/compute-engine/compilation/base-compiler.d.ts

@@ -0,0 +1,31 @@
+/* 0.35.0 */
+import type { CompileTarget, TargetSource } from './types';
+/**
+ * Base compiler class containing language-agnostic compilation logic
+ */
+export declare class BaseCompiler {
+    /**
+     * Compile an expression to target language source code
+     */
+    static compile(expr: BoxedExpression | undefined, target: CompileTarget, prec?: number): TargetSource;
+    /**
+     * Compile a function expression
+     */
+    static compileExpr(engine: ComputeEngine, h: string, args: ReadonlyArray<BoxedExpression>, prec: number, target: CompileTarget): TargetSource;
+    /**
+     * Compile a block expression
+     */
+    private static compileBlock;
+    /**
+     * Compile loop constructs (Sum/Product)
+     */
+    private static compileLoop;
+    /**
+     * Generate a temporary variable name
+     */
+    static tempVar(): string;
+    /**
+     * Inline or wrap expression in IIFE based on complexity
+     */
+    static inlineExpression(body: string, x: string): string;
+}

package/dist/types/compute-engine/compilation/glsl-target.d.ts

@@ -0,0 +1,63 @@
+/* 0.35.0 */
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
+/**
+ * GLSL language target implementation
+ */
+export declare class GLSLTarget implements LanguageTarget {
+    getOperators(): CompiledOperators;
+    getFunctions(): CompiledFunctions;
+    createTarget(options?: Partial<CompileTarget>): CompileTarget;
+    /**
+     * Compile to GLSL source code (not executable)
+     *
+     * GLSL doesn't run in JavaScript, so this returns source code as a string
+     * rather than an executable function.
+     */
+    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+    /**
+     * Compile an expression to GLSL source code
+     *
+     * Returns the GLSL code as a string.
+     */
+    compile(expr: BoxedExpression, options?: CompilationOptions): string;
+    /**
+     * Create a complete GLSL function from an expression
+     *
+     * @param expr - The expression to compile
+     * @param functionName - Name of the GLSL function
+     * @param returnType - GLSL return type (e.g., 'float', 'vec3')
+     * @param parameters - Parameter declarations (e.g., [['x', 'float'], ['y', 'vec3']])
+     */
+    compileFunction(expr: BoxedExpression, functionName: string, returnType: string, parameters: Array<[name: string, type: string]>): string;
+    /**
+     * Create a complete GLSL shader from expressions
+     *
+     * @param options - Shader compilation options
+     */
+    compileShader(options: {
+        /** Shader type: 'vertex' or 'fragment' */
+        type: 'vertex' | 'fragment';
+        /** GLSL version (e.g., '300 es', '330', '450') */
+        version?: string;
+        /** Input variables (attributes or varyings) */
+        inputs?: Array<{
+            name: string;
+            type: string;
+        }>;
+        /** Output variables */
+        outputs?: Array<{
+            name: string;
+            type: string;
+        }>;
+        /** Uniform variables */
+        uniforms?: Array<{
+            name: string;
+            type: string;
+        }>;
+        /** Main function body expressions */
+        body: Array<{
+            variable: string;
+            expression: BoxedExpression;
+        }>;
+    }): string;
+}

package/dist/types/compute-engine/compilation/interval-glsl-target.d.ts

@@ -0,0 +1,51 @@
+/* 0.35.0 */
+ * GLSL interval arithmetic compilation target
+ *
+ * Compiles mathematical expressions to GLSL code using interval arithmetic
+ * for reliable function evaluation in shaders.
+ *
+ * Intervals are represented as vec2(lo, hi).
+ * Status flags use float constants for shader compatibility.
+ *
+ * @module compilation/interval-glsl-target
+ */
+import type { BoxedExpression } from '../global-types';
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
+/**
+ * GLSL interval arithmetic target implementation.
+ */
+export declare class IntervalGLSLTarget implements LanguageTarget {
+    getOperators(): CompiledOperators;
+    getFunctions(): CompiledFunctions;
+    /**
+     * Get the GLSL interval library code.
+     *
+     * This should be included in shaders that use interval arithmetic.
+     */
+    getLibrary(): string;
+    createTarget(options?: Partial<CompileTarget>): CompileTarget;
+    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+    /**
+     * Compile an expression to GLSL interval code.
+     */
+    compile(expr: BoxedExpression, options?: CompilationOptions): string;
+    /**
+     * Create a complete GLSL interval function from an expression.
+     *
+     * @param expr - The expression to compile
+     * @param functionName - Name of the GLSL function
+     * @param parameters - Parameter names (each becomes a vec2 interval input)
+     */
+    compileFunction(expr: BoxedExpression, functionName: string, parameters: string[]): string;
+    /**
+     * Create a complete GLSL fragment shader for interval function plotting.
+     *
+     * @param expr - The expression to compile
+     * @param options - Shader options
+     */
+    compileShaderFunction(expr: BoxedExpression, options?: {
+        functionName?: string;
+        version?: string;
+        parameters?: string[];
+    }): string;
+}

package/dist/types/compute-engine/compilation/interval-javascript-target.d.ts

@@ -0,0 +1,93 @@
+/* 0.35.0 */
+ * JavaScript interval arithmetic compilation target
+ *
+ * Compiles mathematical expressions to JavaScript code using interval arithmetic
+ * for reliable function evaluation with singularity detection.
+ *
+ * @module compilation/interval-javascript-target
+ */
+import type { BoxedExpression } from '../global-types';
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
+/**
+ * JavaScript function that wraps compiled interval arithmetic code.
+ *
+ * Injects the _IA library and provides input conversion from various formats.
+ */
+export declare class ComputeEngineIntervalFunction extends Function {
+    IA: {
+        ok: typeof import("../interval").ok;
+        point: typeof import("../interval").point;
+        containsExtremum: typeof import("../interval").containsExtremum;
+        unionResults: typeof import("../interval").unionResults;
+        mergeDomainClip: typeof import("../interval").mergeDomainClip;
+        isPoint: typeof import("../interval").isPoint;
+        containsZero: typeof import("../interval").containsZero;
+        isPositive: typeof import("../interval").isPositive;
+        isNegative: typeof import("../interval").isNegative;
+        isNonNegative: typeof import("../interval").isNonNegative;
+        isNonPositive: typeof import("../interval").isNonPositive;
+        width: typeof import("../interval").width;
+        midpoint: typeof import("../interval").midpoint;
+        getValue: typeof import("../interval").getValue;
+        unwrap: typeof import("../interval").unwrap;
+        unwrapOrPropagate: typeof import("../interval").unwrapOrPropagate;
+        add: typeof import("../interval").add;
+        sub: typeof import("../interval").sub;
+        mul: typeof import("../interval").mul;
+        div: typeof import("../interval").div;
+        negate: typeof import("../interval").negate;
+        sqrt: typeof import("../interval").sqrt;
+        square: typeof import("../interval").square;
+        pow: typeof import("../interval").pow;
+        powInterval: typeof import("../interval").powInterval;
+        exp: typeof import("../interval").exp;
+        ln: typeof import("../interval").ln;
+        log10: typeof import("../interval").log10;
+        log2: typeof import("../interval").log2;
+        abs: typeof import("../interval").abs;
+        floor: typeof import("../interval").floor;
+        ceil: typeof import("../interval").ceil;
+        round: typeof import("../interval").round;
+        min: typeof import("../interval").min;
+        max: typeof import("../interval").max;
+        mod: typeof import("../interval").mod;
+        sign: typeof import("../interval").sign;
+        sin: typeof import("../interval").sin;
+        cos: typeof import("../interval").cos;
+        tan: typeof import("../interval").tan;
+        cot: typeof import("../interval").cot;
+        sec: typeof import("../interval").sec;
+        csc: typeof import("../interval").csc;
+        asin: typeof import("../interval").asin;
+        acos: typeof import("../interval").acos;
+        atan: typeof import("../interval").atan;
+        atan2: typeof import("../interval").atan2;
+        sinh: typeof import("../interval").sinh;
+        cosh: typeof import("../interval").cosh;
+        tanh: typeof import("../interval").tanh;
+        asinh: typeof import("../interval").asinh;
+        acosh: typeof import("../interval").acosh;
+        atanh: typeof import("../interval").atanh;
+        less: typeof import("../interval").less;
+        lessEqual: typeof import("../interval").lessEqual;
+        greater: typeof import("../interval").greater;
+        greaterEqual: typeof import("../interval").greaterEqual;
+        equal: typeof import("../interval").equal;
+        notEqual: typeof import("../interval").notEqual;
+        and: typeof import("../interval").and;
+        or: typeof import("../interval").or;
+        not: typeof import("../interval").not;
+        piecewise: typeof import("../interval").piecewise;
+        clamp: typeof import("../interval").clamp;
+    };
+    constructor(body: string, preamble?: string);
+}
+/**
+ * Interval arithmetic JavaScript target implementation.
+ */
+export declare class IntervalJavaScriptTarget implements LanguageTarget {
+    getOperators(): CompiledOperators;
+    getFunctions(): CompiledFunctions;
+    createTarget(options?: Partial<CompileTarget>): CompileTarget;
+    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+}

package/dist/types/compute-engine/compilation/javascript-target.d.ts

@@ -0,0 +1,68 @@
+/* 0.35.0 */
+import { chop, factorial, gcd, lcm, limit } from '../numerics/numeric';
+import { gamma, gammaln } from '../numerics/special-functions';
+import { interquartileRange, kurtosis, mean, median, mode, populationStandardDeviation, populationVariance, quartiles, skewness, standardDeviation, variance } from '../numerics/statistics';
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
+/**
+ * JavaScript-specific function extension that provides system functions
+ */
+export declare class ComputeEngineFunction extends Function {
+    SYS: {
+        chop: typeof chop;
+        factorial: typeof factorial;
+        gamma: typeof gamma;
+        gcd: typeof gcd;
+        integrate: (f: any, a: any, b: any) => number;
+        lcm: typeof lcm;
+        lngamma: typeof gammaln;
+        limit: typeof limit;
+        mean: typeof mean;
+        median: typeof median;
+        variance: typeof variance;
+        populationVariance: typeof populationVariance;
+        standardDeviation: typeof standardDeviation;
+        populationStandardDeviation: typeof populationStandardDeviation;
+        kurtosis: typeof kurtosis;
+        skewness: typeof skewness;
+        mode: typeof mode;
+        quartiles: typeof quartiles;
+        interquartileRange: typeof interquartileRange;
+    };
+    constructor(body: string, preamble?: string);
+}
+/**
+ * JavaScript function literal with parameters
+ */
+export declare class ComputeEngineFunctionLiteral extends Function {
+    SYS: {
+        chop: typeof chop;
+        factorial: typeof factorial;
+        gamma: typeof gamma;
+        gcd: typeof gcd;
+        integrate: (f: any, a: any, b: any) => number;
+        lcm: typeof lcm;
+        lngamma: typeof gammaln;
+        limit: typeof limit;
+        mean: typeof mean;
+        median: typeof median;
+        variance: typeof variance;
+        populationVariance: typeof populationVariance;
+        standardDeviation: typeof standardDeviation;
+        populationStandardDeviation: typeof populationStandardDeviation;
+        kurtosis: typeof kurtosis;
+        skewness: typeof skewness;
+        mode: typeof mode;
+        quartiles: typeof quartiles;
+        interquartileRange: typeof interquartileRange;
+    };
+    constructor(body: string, args: string[]);
+}
+/**
+ * JavaScript language target implementation
+ */
+export declare class JavaScriptTarget implements LanguageTarget {
+    getOperators(): CompiledOperators;
+    getFunctions(): CompiledFunctions;
+    createTarget(options?: Partial<CompileTarget>): CompileTarget;
+    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+}

package/dist/types/compute-engine/compilation/types.d.ts

@@ -0,0 +1,140 @@
+/* 0.35.0 */
+import type { BoxedExpression } from '../global-types';
+/**
+ * Source code in the target language
+ */
+export type TargetSource = string;
+/**
+ * A compiled function that can be executed
+ */
+export type CompiledFunction = string | ((args: ReadonlyArray<BoxedExpression>, compile: (expr: BoxedExpression) => TargetSource, target: CompileTarget) => TargetSource);
+/**
+ * Mapping of operators to their target language representation and precedence
+ */
+export type CompiledOperators = Record<MathJsonSymbol, [
+    op: string,
+    prec: number
+]>;
+/**
+ * Mapping of function names to their target language implementation
+ */
+export type CompiledFunctions = {
+    [id: MathJsonSymbol]: CompiledFunction;
+};
+/**
+ * Target language compilation configuration
+ */
+export interface CompileTarget {
+    /** Get operator representation for the target language */
+    operators?: (op: MathJsonSymbol) => [op: string, prec: number] | undefined;
+    /** Get function implementation for the target language */
+    functions?: (id: MathJsonSymbol) => CompiledFunction | undefined;
+    /** Get variable representation for the target language */
+    var: (id: MathJsonSymbol) => string | undefined;
+    /** Format string literals for the target language */
+    string: (str: string) => string;
+    /** Format numeric literals for the target language */
+    number: (n: number) => string;
+    /** Format whitespace for the target language */
+    ws: (s?: string) => string;
+    /** Code to be inserted at the beginning of the compiled output */
+    preamble: string;
+    /** Current indentation level */
+    indent: number;
+    /** Target language identifier (for debugging/logging) */
+    language?: string;
+}
+/**
+ * Base interface for language-specific compilation targets
+ */
+export interface LanguageTarget {
+    /** Get the default operators for this language */
+    getOperators(): CompiledOperators;
+    /** Get the default functions for this language */
+    getFunctions(): CompiledFunctions;
+    /** Create a CompileTarget for this language */
+    createTarget(options?: Partial<CompileTarget>): CompileTarget;
+    /** Compile an expression to executable code in this language */
+    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+}
+/**
+ * Options for compilation
+ */
+export interface CompilationOptions {
+    /**
+     * Target language for compilation.
+     *
+     * Built-in targets:
+     * - `'javascript'` (default) - Compile to JavaScript
+     * - `'glsl'` - Compile to GLSL (OpenGL Shading Language)
+     *
+     * Custom targets can be registered using `ce.registerCompilationTarget()`.
+     *
+     * @example
+     * ```typescript
+     * // Compile to GLSL
+     * const glslCode = expr.compile({ to: 'glsl' });
+     *
+     * // Compile to custom target
+     * ce.registerCompilationTarget('python', new PythonTarget());
+     * const pythonCode = expr.compile({ to: 'python' });
+     * ```
+     */
+    to?: string;
+    /**
+     * Direct compilation target override.
+     *
+     * When provided, this takes precedence over the `to` option.
+     * Useful for one-off custom targets without registration.
+     *
+     * @example
+     * ```typescript
+     * const customTarget: CompileTarget = {
+     *   language: 'custom',
+     *   operators: (op) => ...,
+     *   functions: (id) => ...,
+     *   // ... other methods
+     * };
+     *
+     * const code = expr.compile({ target: customTarget });
+     * ```
+     */
+    target?: CompileTarget;
+    /**
+     * Custom operator mappings. Can be:
+     * - A partial object mapping operator names to [operator, precedence] tuples
+     * - A function that returns the operator mapping for a given symbol
+     *
+     * When an operator is overridden, it will be compiled using the specified
+     * string and precedence instead of the default for the target language.
+     *
+     * @example
+     * ```typescript
+     * // Override operators as object
+     * { operators: { Add: ['add', 11], Multiply: ['mul', 12] } }
+     *
+     * // Override operators as function
+     * { operators: (op) => op === 'Add' ? ['add', 11] : undefined }
+     * ```
+     */
+    operators?: Partial<CompiledOperators> | ((op: MathJsonSymbol) => [op: string, prec: number] | undefined);
+    /** Custom function implementations */
+    functions?: Record<MathJsonSymbol, TargetSource | Function>;
+    /** Variable bindings */
+    vars?: Record<MathJsonSymbol, TargetSource>;
+    /** Additional imports/libraries to include */
+    imports?: unknown[];
+    /** Additional preamble code */
+    preamble?: string;
+}
+/**
+ * A compiled expression that can be executed
+ */
+export interface CompiledExecutable {
+    /** Execute the compiled code */
+    (...args: any[]): any;
+    /** Get the source code */
+    toString(): string;
+    /** Flag indicating this is a compiled expression */
+    isCompiled: true;
+}

package/dist/types/compute-engine/cost-function.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 /**
  * The default cost function, used to determine if a new expression is simpler
  * than the old one.

package/dist/types/compute-engine/function-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 import type { BoxedDefinition, BoxedExpression, ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS