@cortex-js/compute-engine 0.31.0 → 0.32.0

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

@@ -1,66 +0,0 @@
-/* 0.31.0 */
-import { NumericValue } from '../numeric-value/types';
-import type { Rational } from '../numerics/types';
-/**
- * Group terms in a product by common term.
- *
- * All the terms should be canonical.
- * - the arguments should have been flattened for `Multiply`
- *
- * - any argument of power been distributed, i.e.
- *      (ab)^2 ->  a^2 b^2
- * *
- * 3 + √5 + √(x+1) + x^2 + (a+b)^2 + d
- *  -> [ [[3, "d"], [1, 1]],
- *       [[5, "x+1"], [1, 2]],
- *       [[1, "a+b"], [2, 1]]
- *      ]
- *
- */
-export declare class Product {
-    readonly options?: {
-        canonical?: boolean;
-    };
-    engine: ComputeEngine;
-    coefficient: NumericValue;
-    terms: {
-        term: BoxedExpression;
-        exponent: Rational;
-    }[];
-    private _isCanonical;
-    static from(expr: BoxedExpression): Product;
-    constructor(ce: ComputeEngine, xs?: ReadonlyArray<BoxedExpression>, options?: {
-        canonical?: boolean;
-    });
-    /**
-     * Add a term to the product.
-     *
-     * If `this._isCanonical` a running product of exact terms is kept.
-     * Otherwise, terms and their exponent are tallied.
-     */
-    mul(term: BoxedExpression, exp?: Rational): void;
-    /** Divide the product by a term of coefficient */
-    div(term: NumericValue | BoxedExpression): void;
-    /** The terms of the product, grouped by degrees.
-     *
-     * If `mode` is `rational`, rationals are split into separate numerator and
-     * denominator, so that a rational expression can be created later
-     * If `mode` is `expression`, a boxed expression is returned, without
-     * splitting rationals
-     * If `mode` is `numeric`, the literals are combined into one expression
-     *
-     */
-    groupedByDegrees(options?: {
-        mode?: 'rational' | 'expression' | 'numeric';
-    }): {
-        exponent: Rational;
-        terms: BoxedExpression[];
-    }[] | null;
-    asExpression(options?: {
-        numericApproximation: boolean;
-    }): BoxedExpression;
-    /** The product, expressed as a numerator and denominator */
-    asNumeratorDenominator(): [BoxedExpression, BoxedExpression];
-    asRationalExpression(): BoxedExpression;
-}
-export declare function commonTerms(lhs: Product, rhs: Product): [NumericValue, BoxedExpression];

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

@@ -1,129 +0,0 @@
-/* 0.31.0 */
-export declare const ConditionParent: {
-    boolean: string;
-    string: string;
-    expression: string;
-    numeric: string;
-    number: string;
-    symbol: string;
-    complex: string;
-    imaginary: string;
-    real: string;
-    notreal: string;
-    integer: string;
-    rational: string;
-    irrational: string;
-    notzero: string;
-    notone: string;
-    finite: string;
-    infinite: string;
-    positive: string;
-    negative: string;
-    nonnegative: string;
-    nonpositive: string;
-    even: string;
-    odd: string;
-    prime: string;
-    composite: string;
-    constant: string;
-    variable: string;
-    function: string;
-    operator: string;
-    relation: string;
-    equation: string;
-    inequality: string;
-    collection: string;
-    list: string;
-    set: string;
-    tuple: string;
-    single: string;
-    pair: string;
-    triple: string;
-    tensor: string;
-    vector: string;
-    matrix: string;
-    scalar: string;
-    unit: string;
-    dimension: string;
-    angle: string;
-    polynomial: string;
-};
-export declare const CONDITIONS: {
-    boolean: (x: BoxedExpression) => boolean;
-    string: (x: BoxedExpression) => boolean;
-    number: (x: BoxedExpression) => boolean;
-    symbol: (x: BoxedExpression) => boolean;
-    expression: (x: BoxedExpression) => boolean;
-    numeric: (x: BoxedExpression) => boolean;
-    integer: (x: BoxedExpression) => boolean;
-    rational: (x: BoxedExpression) => boolean;
-    irrational: (x: BoxedExpression) => boolean;
-    real: (x: BoxedExpression) => boolean;
-    notreal: (x: BoxedExpression) => boolean;
-    complex: (x: BoxedExpression) => boolean;
-    imaginary: (x: BoxedExpression) => boolean;
-    positive: (x: BoxedExpression) => boolean;
-    negative: (x: BoxedExpression) => boolean;
-    nonnegative: (x: BoxedExpression) => boolean;
-    nonpositive: (x: BoxedExpression) => boolean;
-    even: (x: BoxedExpression) => boolean;
-    odd: (x: BoxedExpression) => boolean;
-    prime: (x: BoxedExpression) => boolean;
-    composite: (x: BoxedExpression) => boolean;
-    notzero: (x: BoxedExpression) => boolean;
-    notone: (x: BoxedExpression) => boolean;
-    finite: (x: BoxedExpression) => boolean;
-    infinite: (x: BoxedExpression) => boolean;
-    constant: (x: BoxedExpression) => boolean;
-    variable: (x: BoxedExpression) => boolean;
-    function: (x: BoxedExpression) => boolean;
-    relation: (x: BoxedExpression) => boolean;
-    equation: (x: BoxedExpression) => boolean;
-    inequality: (x: BoxedExpression) => boolean;
-    collection: (x: BoxedExpression) => boolean;
-    list: (x: BoxedExpression) => boolean;
-    set: (x: BoxedExpression) => boolean;
-    tuple: (x: BoxedExpression) => boolean;
-    single: (x: BoxedExpression) => boolean;
-    pair: (x: BoxedExpression) => boolean;
-    triple: (x: BoxedExpression) => boolean;
-    scalar: (x: BoxedExpression) => boolean;
-    tensor: (x: BoxedExpression) => boolean;
-    vector: (x: BoxedExpression) => boolean;
-    matrix: (x: BoxedExpression) => boolean;
-    unit: (x: BoxedExpression) => boolean;
-    dimension: (x: BoxedExpression) => boolean;
-    angle: (x: BoxedExpression) => boolean;
-    polynomial: (x: BoxedExpression) => boolean;
-};
-export declare function checkConditions(x: BoxedExpression, conditions: string[]): boolean;
-/**
- * Create a boxed rule set from a collection of non-boxed rules
- */
-export declare function boxRules(ce: ComputeEngine, rs: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
-    canonical?: boolean;
-}): BoxedRuleSet;
-/**
- * Apply a rule to an expression, assuming an incoming substitution
- * @param rule the rule to apply
- * @param expr the expression to apply the rule to
- * @param substitution an incoming substitution
- * @param options
- * @returns A transformed expression, if the rule matched. `null` otherwise.
- */
-export declare function applyRule(rule: Readonly<BoxedRule>, expr: BoxedExpression, substitution: BoxedSubstitution, options?: Readonly<Partial<ReplaceOptions>>): RuleStep | null;
-/**
- * Apply the rules in the ruleset and return a modified expression
- * and the set of rules that were applied.
- *
- * The `replace` function can be used to apply a rule to a non-canonical
- * expression.
- *
- */
-export declare function replace(expr: BoxedExpression, rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): RuleSteps;
-/**
- * For each rules in the rule set that match, return the `replace` of the rule
- *
- * @param rules
- */
-export declare function matchAnyRules(expr: BoxedExpression, rules: BoxedRuleSet, sub: BoxedSubstitution, options?: Partial<ReplaceOptions>): BoxedExpression[];

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

@@ -1,3 +0,0 @@
-/* 0.31.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,46 +0,0 @@
-/* 0.31.0 */
-export declare function sgn(expr: BoxedExpression): Sign | undefined;
-/**
- * Sign `s` is > 0.
- *
- * :::info[Note]
- * Returns `undefined` for cases where the given sign is either non-applicable to real numbers
- * ('nan', 'unsigned', 'complex-infinity') or does not convey enough information (e.g. 'real',
- * 'not-zero', 'real-not-zero', 'non-negative').
- * :::
- *
- * @param s
- */
-export declare function positiveSign(s: Sign | undefined): boolean | undefined;
-/**
- * Sign `s` is >= 0.
- *
- *
- * **note**: returns *undefined* where sign does not apply to the field of reals, or does not convey
- * enough information.
- *
- * @param s
- */
-export declare function nonNegativeSign(s: Sign | undefined): boolean | undefined;
-/**
- * Sign `s` is < 0.
- *
- * :::info[Note]
- * Returns `undefined` for cases where the given sign is either non-applicable to real numbers
- * ('nan', 'unsigned', 'complex-infinity') or does not convey enough information (e.g. 'real',
- * 'not-zero', 'real-not-zero', 'non-positive').
- * :::
- *
- * @param s
- */
-export declare function negativeSign(s: Sign | undefined): boolean | undefined;
-/**
- * Sign `s` is <= 0.
- *
- *
- * **note**: returns *undefined* where sign does not apply to the field of reals, or does not convey
- * enough information.
- *
- * @param s
- */
-export declare function nonPositiveSign(s: Sign | undefined): boolean | undefined;

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

@@ -1,6 +0,0 @@
-/* 0.31.0 */
-type InternalSimplifyOptions = SimplifyOptions & {
-    useVariations: boolean;
-};
-export declare function simplify(expr: BoxedExpression, options?: Partial<InternalSimplifyOptions>, steps?: RuleSteps): RuleSteps;
-export {};

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

@@ -1,20 +0,0 @@
-/* 0.31.0 */
-export declare const UNIVARIATE_ROOTS: Rule[];
-/**
- * Expression is a function of a single variable (`x`) or an Equality
- *
- * Return the roots of that variable
- *
- */
-export declare function findUnivariateRoots(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression>;
-/** Expr is an equation with an operator of
- * - `Equal`, `Less`, `Greater`, `LessEqual`, `GreaterEqual`
- *
- * Return an expression with the same operator, but with the first argument
- * a variable, if possible:
- * `2x < 4` => `x < 2`
- */
-export declare function univariateSolve(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression> | null;
-/** Harmonization rules transform an expr into one or more equivalent
- * expressions that are easier to solve */
-export declare const HARMONIZATION_RULES: Rule[];

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

@@ -1,10 +0,0 @@
-/* 0.31.0 */
-export declare class Terms {
-    private engine;
-    private terms;
-    constructor(ce: ComputeEngine, terms: ReadonlyArray<BoxedExpression>);
-    private add;
-    private find;
-    N(): BoxedExpression;
-    asExpression(): BoxedExpression;
-}

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

@@ -1,9 +0,0 @@
-/* 0.31.0 */
-export declare function Fu(exp: BoxedExpression): RuleStep | undefined;
-/** 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;
-export declare function processInverseFunction(ce: ComputeEngine, xs: ReadonlyArray<BoxedExpression>): BoxedExpression | undefined;
-export declare function trigSign(operator: string, x: BoxedExpression): Sign | undefined;
-export declare function isConstructible(x: string | BoxedExpression): boolean;
-export declare function constructibleValues(operator: string, x: BoxedExpression | undefined): undefined | BoxedExpression;

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

@@ -1,64 +0,0 @@
-/* 0.31.0 */
-import { Type } from '../../common/type/types';
-import { NumericValue } from '../numeric-value/types';
-/**
- * Check if an expression contains symbolic transcendental functions of constants
- * (like ln(2), sin(1), etc.) that should not be evaluated numerically.
- *
- * This excludes transcendentals that simplify to exact values, such as:
- * - ln(e) -> 1
- * - sin(0) -> 0
- * - cos(0) -> 1
- */
-export declare function hasSymbolicTranscendental(expr: BoxedExpression): boolean;
-export declare function isDictionary(expr: any | null | undefined): expr is DictionaryInterface;
-export declare function isBoxedExpression(x: unknown): x is BoxedExpression;
-/**
- * For any numeric result, if `bignumPreferred()` is true, calculate using
- * bignums. If `bignumPreferred()` is false, calculate using machine numbers
- */
-export declare function bignumPreferred(ce: ComputeEngine): boolean;
-export declare function hashCode(s: string): number;
-export declare function normalizedUnknownsForSolve(syms: string | Iterable<string> | BoxedExpression | Iterable<BoxedExpression> | null | undefined): string[];
-/** Return the local variables in the expression.
- *
- * A local variable is a symbol that is declared with a `Declare`
- * expression in a `Block` expression.
- *
- */
-export declare function getLocalVariables(expr: BoxedExpression): string[];
-export declare function domainToType(expr: BoxedExpression): Type;
-/**
- * Return the angle in the range [0, 2π) that is equivalent to the given angle.
- *
- * @param x
- * @returns
- */
-export declare function canonicalAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
-/**
- * Return a multiple of the imaginary unit, e.g.
- * - 'ImaginaryUnit'  -> 1
- * - ['Negate', 'ImaginaryUnit']  -> -1
- * - ['Negate', ['Multiply', 3, 'ImaginaryUnit']] -> -3
- * - ['Multiply', 5, 'ImaginaryUnit'] -> 5
- * - ['Multiply', 'ImaginaryUnit', 5] -> 5
- * - ['Divide', 'ImaginaryUnit', 2] -> 0.5
- *
- */
-export declare function getImaginaryFactor(expr: number | BoxedExpression): BoxedExpression | undefined;
-/**
- * `true` if expr is a number with imaginary part 1 and real part 0, or a symbol with a definition
- * matching this. Does not bind expr if a symbol.
- *
- * @export
- * @param expr
- * @returns
- */
-export declare function isImaginaryUnit(expr: BoxedExpression): boolean;
-export declare function getPiTerm(expr: BoxedExpression): [k: NumericValue, t: NumericValue];
-export declare function isValidOperatorDef(def: any): def is Partial<OperatorDefinition>;
-export declare function isValidValueDef(def: any): def is Partial<ValueDefinition>;
-export declare function isValueDef(def: BoxedDefinition | undefined): def is TaggedValueDefinition;
-export declare function isOperatorDef(def: BoxedDefinition | undefined): def is TaggedOperatorDefinition;
-export declare function updateDef(ce: ComputeEngine, name: string, def: BoxedDefinition, newDef: Partial<OperatorDefinition> | BoxedOperatorDefinition | Partial<ValueDefinition> | BoxedValueDefinition): void;
-export declare function placeholderDef(ce: ComputeEngine, name: string): BoxedDefinition;

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

@@ -1,58 +0,0 @@
-/* 0.31.0 */
-import type { BoxedExpression, ComputeEngine } from '../global-types';
-/**
- * Check that the number of arguments is as expected.
- *
- * Converts the arguments to canonical, and flattens the sequence.
- */
-export declare function checkArity(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, count: number): ReadonlyArray<BoxedExpression>;
-/**
- * Validation of arguments is normally done by checking the signature of the
- * function vs the arguments of the expression. However, we have a fastpath
- * for some common operations (add, multiply, power, neg, etc...) that bypasses
- * the regular checks. This is its replacements.
- *
- * Since all those fastpath functions are numeric (i.e. have numeric arguments
- * and a numeric result), we do a simple numeric check of all arguments, and
- * verify we have the number of expected arguments.
- *
- * We also assume that the function is threadable.
- *
- * The arguments are made canonical.
- *
- * Flattens sequence expressions.
- */
-export declare function checkNumericArgs(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, options?: number | {
-    count?: number;
-    flatten?: string;
-}): ReadonlyArray<BoxedExpression>;
-/**
- * Check that an argument is of the expected type.
- *
- * Converts the arguments to canonical
- */
-export declare function checkType(ce: ComputeEngine, arg: BoxedExpression | undefined | null, type: Type | undefined): BoxedExpression;
-export declare function checkTypes(ce: ComputeEngine, args: ReadonlyArray<BoxedExpression>, types: Type[]): ReadonlyArray<BoxedExpression>;
-/**
- * Check that the argument is pure.
- */
-export declare function checkPure(ce: ComputeEngine, arg: BoxedExpression | BoxedExpression | undefined | null): BoxedExpression;
-/**
- *
- * If the arguments match the parameters, return null.
- *
- * Otherwise return a list of expressions indicating the mismatched
- * arguments.
- *
- * <!--
- * @todo?:
- * - Some permutations of operands should perhaps always be treated as invalid. Consider:
- *   - A sequence wildcard (non-optional, i.e. '__') followed by either a universal wildcard ('_'),
- *   or another non-optional sequence wildcard. (note that an optional sequence wildcard is
- *   unproblematic here.)
- *
- * -->
- *
- */
-export declare function validateArguments(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, signature: Type, lazy?: boolean, threadable?: boolean): ReadonlyArray<BoxedExpression> | null;
-export declare function spellCheckMessage(expr: BoxedExpression): string;

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

@@ -1,35 +0,0 @@
-/* 0.31.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
- * result in a set with 20 elements.
- *
- * If the sum of the sizes of the two sets is greater than
- * `MAX_SIZE_EAGER_COLLECTION`, the result is a Union expression
- *
- */
-export declare const MAX_SIZE_EAGER_COLLECTION = 100;
-export declare function isFiniteIndexedCollection(col: BoxedExpression): boolean;
-export declare function repeat(value: BoxedExpression, count?: number): Iterator<BoxedExpression>;
-/**
- * Zips together multiple collections into a single iterator.
- *
- * Example:
- * ```typescript
- * const a = ce.box(['List', 1, 2, 3]);
- * const b = ce.box(['List', 4, 5, 6]);
- * const zipped = zip([a, b]);
- * for (const [x, y] of zipped) {
- *   console.log(x, y); // 1 4, 2 5, 3 6
- * }
- * ```
- */
-export declare function zip(items: ReadonlyArray<BoxedExpression>): Iterator<BoxedExpression[]>;
-/**
- * Default collection handlers suitable for collections that store their
- * elements as operands.
- *
- * This is the case for List, Tuple, etc.
- */
-export declare function basicIndexedCollectionHandlers(): CollectionHandlers;
-export declare function defaultCollectionHandlers(def: undefined | CollectionHandlers): CollectionHandlers | undefined;

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

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

@@ -1,68 +0,0 @@
-/* 0.31.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

@@ -1,83 +0,0 @@
-/* 0.31.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 {
-    /** 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,13 +0,0 @@
-/* 0.31.0 */
-/**
- * The default cost function, used to determine if a new expression is simpler
- * than the old one.
- *
- * To change the cost function used by the engine, set the
- * `ce.costFunction` property of the engine or pass a custom cost function
- * to the `simplify` function.
- *
- */
-export declare function costFunction(expr: BoxedExpression): number;
-export declare function leafCount(expr: BoxedExpression): number;
-export declare const DEFAULT_COST_FUNCTION: typeof costFunction;