@cortex-js/compute-engine 0.33.0 → 0.34.0

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /** @internal */
 type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
 /** A `SmallInteger` is an integer < 1e6

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

@@ -0,0 +1,85 @@
+/* 0.34.0 */
+ * OEIS (Online Encyclopedia of Integer Sequences) Integration
+ *
+ * This module provides functions to look up sequences in the OEIS database
+ * and import them for use in the compute engine.
+ *
+ * @see https://oeis.org
+ */
+import type { ComputeEngine, BoxedExpression } from './global-types';
+/**
+ * Result from an OEIS lookup operation.
+ */
+export interface OEISSequenceInfo {
+    /** OEIS sequence ID (e.g., 'A000045') */
+    id: string;
+    /** Sequence name/description */
+    name: string;
+    /** First several terms of the sequence */
+    terms: number[];
+    /** Formula or recurrence (if available) */
+    formula?: string;
+    /** Comments about the sequence */
+    comments?: string[];
+    /** URL to the OEIS page */
+    url: string;
+}
+/**
+ * Options for OEIS operations.
+ */
+export interface OEISOptions {
+    /** Request timeout in milliseconds (default: 10000) */
+    timeout?: number;
+    /** Maximum number of results to return for lookups (default: 5) */
+    maxResults?: number;
+}
+/**
+ * Look up sequences in OEIS by their terms.
+ *
+ * @param terms - Array of sequence terms to search for
+ * @param options - Optional configuration
+ * @returns Promise resolving to array of matching sequences
+ *
+ * @example
+ * ```typescript
+ * const results = await lookupOEISByTerms([0, 1, 1, 2, 3, 5, 8, 13]);
+ * // → [{ id: 'A000045', name: 'Fibonacci numbers', ... }]
+ * ```
+ */
+export declare function lookupOEISByTerms(terms: number[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
+/**
+ * Look up a sequence in OEIS by its ID.
+ *
+ * @param id - OEIS sequence ID (e.g., 'A000045' or '45')
+ * @param options - Optional configuration
+ * @returns Promise resolving to sequence info, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const fib = await lookupOEISById('A000045');
+ * // → { id: 'A000045', name: 'Fibonacci numbers', terms: [0, 1, 1, 2, ...], ... }
+ * ```
+ */
+export declare function lookupOEISById(id: string, options?: OEISOptions): Promise<OEISSequenceInfo | undefined>;
+/**
+ * Look up a sequence in OEIS by its terms.
+ *
+ * @param ce - ComputeEngine instance
+ * @param terms - Array of sequence terms (numbers or BoxedExpressions)
+ * @param options - Optional configuration
+ * @returns Promise resolving to array of matching sequences
+ */
+export declare function lookupSequence(ce: ComputeEngine, terms: (number | BoxedExpression)[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
+/**
+ * Check if a defined sequence matches an OEIS sequence.
+ *
+ * @param ce - ComputeEngine instance
+ * @param name - Name of the defined sequence
+ * @param count - Number of terms to check (default: 10)
+ * @param options - Optional configuration
+ * @returns Promise with match results
+ */
+export declare function checkSequence(ce: ComputeEngine, name: string, count?: number, options?: OEISOptions): Promise<{
+    matches: OEISSequenceInfo[];
+    terms: number[];
+}>;

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

@@ -0,0 +1,120 @@
+/* 0.34.0 */
+ * Utilities for declarative sequence definitions.
+ *
+ * This module provides functions to create subscriptEvaluate handlers
+ * from sequence definitions (base cases + recurrence relation).
+ */
+import type { BoxedExpression, ComputeEngine, SequenceDefinition, SequenceStatus, SequenceInfo } from './global-types';
+/**
+ * Create a subscriptEvaluate handler from a sequence definition.
+ *
+ * The handler evaluates expressions like `F_{10}` or `P_{5,2}` by:
+ * 1. Checking base cases first (with pattern matching for multi-index)
+ * 2. Looking up memoized values
+ * 3. Recursively evaluating the recurrence relation
+ *
+ * Supports both single-index and multi-index sequences:
+ * - Single-index: `F_{10}` with subscript as a number
+ * - Multi-index: `P_{5,2}` with subscript as `Sequence(5, 2)`
+ */
+export declare function createSequenceHandler(ce: ComputeEngine, name: string, def: SequenceDefinition): (subscript: BoxedExpression, options: {
+    engine: ComputeEngine;
+    numericApproximation?: boolean;
+}) => BoxedExpression | undefined;
+/**
+ * Validate a sequence definition.
+ */
+export declare function validateSequenceDefinition(ce: ComputeEngine, name: string, def: SequenceDefinition): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Add a base case for a single-index sequence definition.
+ * e.g., from `L_0 := 1`
+ */
+export declare function addSequenceBaseCase(ce: ComputeEngine, name: string, index: number, value: BoxedExpression): void;
+/**
+ * Add a base case for a multi-index sequence definition.
+ * e.g., from `P_{0,0} := 1` or `P_{n,0} := 1`
+ *
+ * @param key - The base case key, e.g., '0,0' for exact or 'n,0' for pattern
+ */
+export declare function addMultiIndexBaseCase(ce: ComputeEngine, name: string, key: string, value: BoxedExpression): void;
+/**
+ * Add a recurrence relation for a single-index sequence definition.
+ * e.g., from `L_n := L_{n-1} + 1`
+ *
+ * We store the recurrence as a LaTeX string rather than a BoxedExpression
+ * because the expression may have been parsed before the symbol was declared
+ * with subscriptEvaluate. Storing as LaTeX allows us to re-parse fresh when
+ * creating the handler, ensuring proper binding.
+ */
+export declare function addSequenceRecurrence(ce: ComputeEngine, name: string, variable: string, expr: BoxedExpression): void;
+/**
+ * Add a recurrence relation for a multi-index sequence definition.
+ * e.g., from `P_{n,k} := P_{n-1,k-1} + P_{n-1,k}`
+ *
+ * @param variables - The index variable names, e.g., ['n', 'k']
+ */
+export declare function addMultiIndexRecurrence(ce: ComputeEngine, name: string, variables: string[], expr: BoxedExpression): void;
+/**
+ * Check if expression contains self-reference to sequence name.
+ * e.g., `a_{n-1}` when defining sequence 'a'
+ */
+export declare function containsSelfReference(expr: BoxedExpression, seqName: string): boolean;
+/**
+ * Extract the index variable from a subscript expression.
+ * e.g., from `n-1` extract 'n', from `2*k` extract 'k'
+ */
+export declare function extractIndexVariable(subscript: BoxedExpression): string | undefined;
+/**
+ * Get the status of a sequence definition.
+ *
+ * Returns information about whether a sequence is complete, pending, or not defined.
+ * Supports both single-index and multi-index sequences.
+ */
+export declare function getSequenceStatus(ce: ComputeEngine, name: string): SequenceStatus;
+/**
+ * Get information about a defined sequence.
+ * Returns `undefined` if the symbol is not a complete sequence.
+ * Supports both single-index and multi-index sequences.
+ */
+export declare function getSequenceInfo(ce: ComputeEngine, name: string): SequenceInfo | undefined;
+/**
+ * List all defined sequences.
+ */
+export declare function listSequences(ce: ComputeEngine): string[];
+/**
+ * Check if a symbol is a defined sequence.
+ */
+export declare function isSequence(ce: ComputeEngine, name: string): boolean;
+/**
+ * Clear the memoization cache for a sequence or all sequences.
+ */
+export declare function clearSequenceCache(ce: ComputeEngine, name?: string): void;
+/**
+ * Get the memoization cache for a sequence.
+ * Returns a copy of the cache Map, or `undefined` if not a sequence or memoization is disabled.
+ *
+ * For single-index sequences, keys are numbers.
+ * For multi-index sequences, keys are comma-separated strings (e.g., '5,2').
+ */
+export declare function getSequenceCache(ce: ComputeEngine, name: string): Map<number | string, BoxedExpression> | undefined;
+/**
+ * Generate a list of sequence terms from start to end (inclusive).
+ *
+ * @param ce - The compute engine
+ * @param name - The sequence name
+ * @param start - Starting index (inclusive)
+ * @param end - Ending index (inclusive)
+ * @param step - Step size (default: 1)
+ * @returns Array of BoxedExpressions for each term, or undefined if not a sequence
+ *
+ * @example
+ * ```typescript
+ * // For Fibonacci sequence F
+ * generateSequenceTerms(ce, 'F', 0, 10);
+ * // → [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+ * ```
+ */
+export declare function generateSequenceTerms(ce: ComputeEngine, name: string, start: number, end: number, step?: number): BoxedExpression[] | undefined;

package/dist/types/compute-engine/symbolic/antiderivative.d.ts

@@ -1,3 +1,3 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /** Calculate the antiderivative of fn, as an expression (not a function) */
 export declare function antiderivative(fn: BoxedExpression, index: string): BoxedExpression;

package/dist/types/compute-engine/symbolic/derivative.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /**
  *
  * @param fn The function to differentiate, a function literal.
@@ -14,5 +14,20 @@ export declare function derivative(fn: BoxedExpression, order: number): BoxedExp
  * All expressions that do not explicitly depend on `v` are taken to have zero
  * partial derivative.
  *
+ * ## Recursion Safety
+ *
+ * This function includes a depth limit (`MAX_DIFFERENTIATION_DEPTH`) to prevent
+ * stack overflow from pathological expressions. The depth is tracked internally
+ * and incremented on each recursive call. If the limit is reached, the function
+ * returns `undefined` rather than continuing to recurse.
+ *
+ * Normal differentiation (including higher-order derivatives of complex
+ * expressions) should never approach this limit. Hitting the limit indicates
+ * either a bug in the differentiation rules or a maliciously constructed input.
+ *
+ * @param expr - The expression to differentiate
+ * @param v - The variable to differentiate with respect to
+ * @param depth - Internal recursion depth counter (do not pass manually)
+ * @returns The derivative expression, or `undefined` if unable to differentiate
  */
-export declare function differentiate(expr: BoxedExpression, v: string): BoxedExpression | undefined;
+export declare function differentiate(expr: BoxedExpression, v: string, depth?: number): BoxedExpression | undefined;

package/dist/types/compute-engine/symbolic/distribute.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /**
  *
  */

package/dist/types/compute-engine/symbolic/fu-cost.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
  * Cost functions for the Fu trigonometric simplification algorithm.
  *
  * The primary objective is to minimize the number of trigonometric functions,

package/dist/types/compute-engine/symbolic/fu-transforms.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
  * Fu Algorithm Transformation Rules
  *
  * Programmatic implementations of TR1-TR22 from the Fu trigonometric

package/dist/types/compute-engine/symbolic/fu.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
  * Fu Algorithm for Trigonometric Simplification
  *
  * Implementation of the algorithm by Fu, Zhong, and Zeng:

package/dist/types/compute-engine/symbolic/simplify-abs.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 export declare function simplifyAbs(x: BoxedExpression): RuleStep | undefined;
 /**
  * Simplify expressions where Abs appears as the base of a power.

package/dist/types/compute-engine/symbolic/simplify-divide.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /**
  * Division simplification rules consolidated from simplify-rules.ts.
  * Handles ~5 patterns for simplifying Divide expressions.

package/dist/types/compute-engine/symbolic/simplify-hyperbolic.d.ts

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.34.0 */
 export declare function simplifyHyperbolic(x: BoxedExpression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-infinity.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /**
  * Infinity simplification rules consolidated from simplify-rules.ts.
  * Handles ~20 patterns for simplifying expressions involving infinity.

package/dist/types/compute-engine/symbolic/simplify-log.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /**
  * Logarithm simplification rules consolidated from simplify-rules.ts.
  * Handles ~30 patterns for simplifying Ln and Log expressions.

package/dist/types/compute-engine/symbolic/simplify-power.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /**
  * Power simplification rules consolidated from simplify-rules.ts.
  * Handles ~25 patterns for simplifying Power expressions.

package/dist/types/compute-engine/symbolic/simplify-product.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /**
  * Product simplification rules extracted from simplify-rules.ts.
  * Handles 13 patterns for simplifying Product expressions.

package/dist/types/compute-engine/symbolic/simplify-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /**
  * A set of simplification rules.
  *

package/dist/types/compute-engine/symbolic/simplify-sum.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /**
  * Sum simplification rules extracted from simplify-rules.ts.
  * Handles 16 patterns for simplifying Sum expressions.

package/dist/types/compute-engine/symbolic/simplify-trig.d.ts

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.34.0 */
 export declare function simplifyTrig(x: BoxedExpression): RuleStep | undefined;

package/dist/types/compute-engine/tensor/tensor-fields.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 import { BoxedExpression, ComputeEngine, DataTypeMap, TensorDataType, TensorField } from '../global-types';
 /** @category Tensors */
 export declare function makeTensorField<DT extends keyof DataTypeMap>(ce: ComputeEngine, dtype: DT): TensorField<DataTypeMap[DT]>;

package/dist/types/compute-engine/tensor/tensors.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 /** @category Tensors */
 export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
     private ce;

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 export * from '../math-json/types';
 export * from '../common/type/boxed-type';
 export * from '../common/type/types';

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

@@ -1,3 +1,7 @@
-/* 0.33.0 */
+/* 0.34.0 */
 export { ComputeEngine } from './compute-engine/index';
 export * from './compute-engine/types';
+export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompiledExecutable, LanguageTarget, TargetSource, CompiledFunction, } from './compute-engine/compilation/types';
+export { JavaScriptTarget } from './compute-engine/compilation/javascript-target';
+export { GLSLTarget } from './compute-engine/compilation/glsl-target';
+export { BaseCompiler } from './compute-engine/compilation/base-compiler';

package/dist/types/math-json/symbols.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
  * Return true if the string is a valid symbol.
  *
  * Check for symbols matching a profile of [Unicode UAX31](https://unicode.org/reports/tr31/)

package/dist/types/math-json/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
  * The following properties can be added to any MathJSON expression
  * to provide additional information about the expression.
  *

package/dist/types/math-json/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.34.0 */
 export declare const MISSING: Expression;
 export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumberObject;
 export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumberObject;

package/dist/types/math-json.d.ts

@@ -1,3 +1,3 @@
-/* 0.33.0 */
+/* 0.34.0 */
 export { isSymbolObject, isStringObject, isFunctionObject, stringValue, operator, operand, symbol, mapArgs, dictionaryFromExpression, } from './math-json/utils';
-export declare const version = "0.33.0";
+export declare const version = "0.34.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.33.0",
+  "version": "0.34.0",
   "scripts": {
     "doc": "bash ./scripts/doc.sh",
     "build": "bash ./scripts/build.sh",
@@ -79,7 +79,7 @@
     "jest-silent-reporter": "^0.6.0",
     "open": "^10.1.2",
     "prettier": "^3.6.2",
-    "prettier-2": "npm:prettier@^2",
+    "prettier-2": "npm:prettier@^2.8.8",
     "serve-http": "^1.0.7",
     "ts-jest": "^29.4.0",
     "ts-node": "^10.9.2",