@cortex-js/compute-engine 0.30.2 → 0.32.0

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

@@ -1,54 +0,0 @@
-/* 0.30.2 */
-import { Type } from '../../common/type/types';
-import { NumericValue } from '../numeric-value/types';
-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,49 +0,0 @@
-/* 0.30.2 */
-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.
- *
- */
-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.30.2 */
-/** 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/compile.d.ts

@@ -1,80 +0,0 @@
-/* 0.30.2 */
-import { BoxedExpression, JSSource } from './global-types';
-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';
-export type CompiledOperators = Record<MathJsonSymbol, [
-    op: string,
-    prec: number
-]>;
-export type CompiledFunction = string | ((args: ReadonlyArray<BoxedExpression>, compile: (expr: BoxedExpression) => JSSource, target: CompileTarget) => JSSource);
-export type CompiledFunctions = {
-    [id: MathJsonSymbol]: CompiledFunction;
-};
-export type CompileTarget = {
-    operators?: (op: MathJsonSymbol) => [op: string, prec: number] | undefined;
-    functions?: (id: MathJsonSymbol) => CompiledFunction | undefined;
-    var: (id: MathJsonSymbol) => string | undefined;
-    string: (str: string) => string;
-    number: (n: number) => string;
-    ws: (s?: string) => string;
-    preamble: string;
-    indent: number;
-};
-/** This is an extension of the Function class that allows us to pass
- * a custom scope for "global" 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);
-}
-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[]);
-}
-export declare function compileToTarget(expr: BoxedExpression, target: CompileTarget): ((...args: any[]) => any) & {
-    isCompiled: true;
-};
-export declare function compileToJavaScript(expr: BoxedExpression, functions?: Record<MathJsonSymbol, JSSource | Function>, vars?: Record<MathJsonSymbol, JSSource>, imports?: unknown[], preamble?: string): ((...args: any[]) => any) & {
-    isCompiled: true;
-};
-export declare function compile(expr: BoxedExpression | undefined, target: CompileTarget, prec?: number): JSSource;

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

@@ -1,13 +0,0 @@
-/* 0.30.2 */
-/**
- * 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;

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

@@ -1,120 +0,0 @@
-/* 0.30.2 */
-import type { BoxedDefinition, BoxedExpression, ComputeEngine, Scope } from './global-types';
-/***
- * ### THEORY OF OPERATIONS
- *
- * The body of a `["Function"]` expression is a `["Block"]` expression,
- * which is scoped. The function arguments are declared in that scope as well.
- *
- * Some expressions with anonymous parameters (e.g. `["Add", "_", 1]`)
- * are rewritten to a `["Function"]` expression with anonymous parameters
- * (e.g. `["Function", ["Block", ["Add", "_", 1]], "_"]`).
- *
- *
- * #### DURING BOXING (in makeLambda())
- *
- * During the boxing/canonicalization phase of a function
- * (`["Function"]` expression or operator of expression):
- *
- * 1/ If not a `["Function"]` expression, the expression is rewritten
- *    to a `["Function"]` expression with anonymous parameters
- * 2/ A new scope is created
- * 3/ The function parameters are declared in the scope
- * 4/ The function body is boxed in the context of the scope and the scope
- *    is associated with the function
- *
- *
- * #### DURING EVALUATION (executing the result of makeLambda())
- *
- * 1/ The arguments are evaluated in the current scope
- * 2/ The context is swapped to the function scope
- * 3/ The function parameters are set to the value of the arguments
- * 4/ The function body is evaluated in the context of the function scope
- * 5/ The context is swapped back to the current scope
- * 6/ The result of the function body is returned
- *
- */
-/**
- * From an expression, return a predicate function, which can be used to filter.
- */
-export declare function predicate(_expr: BoxedExpression): (...args: BoxedExpression[]) => boolean;
-/**
- * From an expression, create an ordering function, which can be used to sort.
- */
-export declare function order(_expr: BoxedExpression): (a: BoxedExpression, b: BoxedExpression) => -1 | 0 | 1;
-/**
- * Given an expression, rewrite it to a symbol or canonical Function form.
- *
- * - symbol (no change):
- *      "Sin"
- *     -> "Sin"
- *
- * - built-in function:
- *      ["BuiltinFunction", "Sin"]
- *     -> "Sin"
- *
- * - parenthesized expression:
- *      ["Delimiter", ["Add", "_", 1], "'()'"]
- *     -> ["Function", ["Block", ["Add", "_", 1]], "_"]
- *
- * - explicit parameters (adding a block to serve as a scope for the arguments):
- *      ["Function", ["Add", "x", 1], "x"]
- *      -> ["Function", ["Block", ["Add", "x", 1]], "x"]
- *
- *
- * - single anonymous parameters:
- *      ["Add", "_", 1]
- *      -> ["Function", ["Block", ["Add", "_", 1]], "_"]
- *
- * - multiple anonymous parameters:
- *      ["Add", "_1", "_2"]
- *      -> ["Function", ["Block", ["Add", "_1", "_2"]], "_1", "_2"]
- *
- *
- */
-export declare function canonicalFunctionLiteral(expr: BoxedExpression | undefined): BoxedExpression | undefined;
-/** Assuming that ops has the following form:
- * - body
- * - ...params
- * return a canonical function literal (["Function", body, ...params]) where
- * body is potentially wrapped in a Block expression and the arguments are
- * declared in the scope of the body.
- */
-export declare function canonicalFunctionLiteralArguments(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | undefined;
-/**
- * Apply arguments to an expression which is either:
- * - a `["Function"]` expression
- * - the symbol for a function, e.g. `Sin`.
- */
-export declare function apply(fn: BoxedExpression, args: ReadonlyArray<BoxedExpression>): BoxedExpression;
-/**
- * Return a lambda function, assuming a scoped environment has been
- * created and there is a single numeric argument
- */
-export declare function makeLambdaN1(expr: BoxedExpression): ((arg: number) => number) | undefined;
-/**
- * Given an expression such as:
- * - ["Function", ["Add", 1, "x"], "x"]
- * - ["Function", ["Divide", "_", 2]]
- * - ["Multiply, "_", 3]
- * - ["Add, "_1", "_2"]
- * - "Sin"
- *
- * return a JS function that can be called with arguments.
- */
-export declare function applicable(fn: BoxedExpression): (xs: ReadonlyArray<BoxedExpression>) => BoxedExpression | undefined;
-/**
- * Use `applicableN1()` when the function is known to be a function with a
- * single real argument that returns a real value.
- *
- * Unlike `apply()`, `applicableN1()` returns a function that can be called
- * with an argument.
- *
- */
-export declare function applicableN1(fn: BoxedExpression): (x: number) => number;
-/**
- * Given a string like "f(x,y)" return, ["f", ["x", "y"]]
- */
-export declare function parseFunctionSignature(s: string): [id: string, args: string[] | undefined];
-/** Lookup a definition matching a symbol in a lexical scope chain */
-export declare function lookup(id: MathJsonSymbol, scope: Scope): undefined | BoxedDefinition;