@cortex-js/compute-engine 0.32.1 → 0.34.0

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

@@ -1,6 +1,52 @@
-/* 0.32.1 */
+/* 0.34.0 */
 /** Combine rational expressions into a single fraction */
 export declare function together(op: BoxedExpression): BoxedExpression;
+/**
+ * Detect if an expression is a perfect square trinomial.
+ * Returns the factored form (a±b)² if successful, null otherwise.
+ *
+ * Patterns:
+ * - a² + 2ab + b² → (a+b)²
+ * - a² - 2ab + b² → (a-b)²
+ *
+ * Strategy: Try to extract square roots of each term to find the bases a and b,
+ * then verify the middle term matches ±2ab.
+ *
+ * IMPORTANT: Does not call .simplify() to avoid infinite recursion.
+ */
+export declare function factorPerfectSquare(expr: BoxedExpression): BoxedExpression | null;
+/**
+ * Detect if an expression is a difference of squares.
+ * Returns the factored form (a-b)(a+b) if successful, null otherwise.
+ *
+ * Pattern: a² - b² → (a-b)(a+b)
+ *
+ * IMPORTANT: Does not call .simplify() on the result to avoid infinite recursion.
+ */
+export declare function factorDifferenceOfSquares(expr: BoxedExpression): BoxedExpression | null;
+/**
+ * Factor a quadratic polynomial using the quadratic formula.
+ * Returns factored form if successful, null otherwise.
+ *
+ * For ax² + bx + c, finds roots r₁ and r₂ and returns:
+ * - a(x - r₁)(x - r₂) if both roots are rational
+ * - null if not a quadratic or roots are complex/irrational
+ *
+ * IMPORTANT: Does not call .simplify() to avoid infinite recursion.
+ */
+export declare function factorQuadratic(expr: BoxedExpression, variable: string): BoxedExpression | null;
+/**
+ * Factor a polynomial expression.
+ * Attempts various factoring strategies:
+ * 1. Perfect square trinomials
+ * 2. Difference of squares
+ * 3. Quadratic factoring (for rational roots)
+ *
+ * Falls back to the existing factor() function if polynomial factoring doesn't apply.
+ *
+ * IMPORTANT: Does not call .simplify() to avoid infinite recursion.
+ */
+export declare function factorPolynomial(expr: BoxedExpression, variable?: string): BoxedExpression;
 /**
  * Return an expression factored as a product.
  * - 2x + 4 -> 2(x + 2)

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 /**
  *
  * Make all the arguments canonical.

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 /** Apply the function `f` to each operand of the expression `expr`,
  * account for the 'lazy' property of the operator definition:
  *

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 /**
  * The function attempts to match a subject expression to a
  * [pattern](/compute-engine/guides/patterns-and-rules/).

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import { Decimal } from 'decimal.js';
 import type { Rational } from '../numerics/types';
 import type { BoxedExpression, SemiBoxedExpression } from '../global-types';

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 export declare const DEFAULT_COMPLEXITY = 100000;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import { NumericValue } from '../numeric-value/types';
 import type { Rational } from '../numerics/types';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const ConditionParent: {
     boolean: string;
     string: string;

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

@@ -1,3 +1,3 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import type { ComputeEngine, BoxedExpression, JsonSerializationOptions } from '../global-types';
 export declare function serializeJson(ce: ComputeEngine, expr: BoxedExpression, options: Readonly<JsonSerializationOptions>): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare function sgn(expr: BoxedExpression): Sign | undefined;
 /**
  * Sign `s` is > 0.

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };

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

@@ -0,0 +1,60 @@
+/* 0.34.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.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.0 */
 export declare class Terms {
     private engine;
     private terms;

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

@@ -1,5 +1,4 @@
-/* 0.32.1 */
-export declare function Fu(exp: BoxedExpression): RuleStep | undefined;
+/* 0.34.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.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic

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

@@ -0,0 +1,63 @@
+/* 0.34.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/javascript-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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';

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import type { BoxedExpression } from '../global-types';
 /**
  * Source code in the target language
@@ -61,6 +61,63 @@ export interface LanguageTarget {
  * 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 */

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.0 */
 import type { BoxedDefinition, BoxedExpression, ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS