@cortex-js/compute-engine 0.29.1 → 0.30.1

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<BoxedExpression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 /** Combine rational expressions into a single fraction */
 export declare function together(op: BoxedExpression): BoxedExpression;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 /**
  *
  * Make all the arguments canonical.

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

@@ -1,6 +1,6 @@
-/* 0.29.1 */
+/* 0.30.1 */
 /** Apply the function `f` to each operand of the expression `expr`,
- * account for the 'lazy' property of the function definition:
+ * account for the 'lazy' property of the operator definition:
  *
  * Account for `Hold`, `ReleaseHold`, `Sequence`, `Symbol` and `Nothing`.
  *

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 /**
  * 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.29.1 */
+/* 0.30.1 */
 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,7 +1,34 @@
-/* 0.29.1 */
+/* 0.30.1 */
+import { Decimal } from 'decimal.js';
 import type { Rational } from '../numerics/types';
-import type { BoxedExpression } from '../global-types';
+import type { BoxedExpression, SemiBoxedExpression } from '../global-types';
 export declare function asRational(expr: BoxedExpression): Rational | undefined;
-export declare function asBigint(expr: BoxedExpression | undefined): bigint | null;
+export declare function asBigint(x: Complex | Decimal | SemiBoxedExpression | undefined): bigint | null;
 export declare function asBignum(expr: BoxedExpression | undefined): Decimal | null;
+/**
+ * Validate if the expression is a small integer.
+ * A small integer is an integer between -SMALL_INTEGER and SMALL_INTEGER (inclusive).
+ * Returns null if the expression is not a small integer.
+ *
+ * Unlike `toInteger()` this functions fails if the expression is not an
+ * integer. `toInteger()` will round the value to the nearest integer.
+ */
 export declare function asSmallInteger(expr: number | BoxedExpression | undefined): number | null;
+/**
+ * Convert a boxed expression to an integer.
+ * Returns null if the expression cannot be converted to an integer.
+ * If the expression is a complex number, only the real part is considered.
+ * If the real part is not an integer, it is rounded to the nearest integer.
+ *
+ * Unlike `asSmallInteger()`, this function does not check if the integer is
+ * within the range of -SMALL_INTEGER to SMALL_INTEGER, and it rounds the
+ * value to the nearest integer if it is a number.
+ *
+ */
+export declare function toInteger(expr: BoxedExpression | undefined): number | null;
+/** Convert a boxed expression to a bigint.
+ * Returns null if the expression cannot be converted to a bigint.
+ * If the expression is a complex number, only the real part is considered.
+ * If the real part is not an integer, it is rounded to the nearest integer.
+ */
+export declare function toBigint(expr: BoxedExpression | undefined): bigint | null;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 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.29.1 */
+/* 0.30.1 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

@@ -1,6 +1,6 @@
-/* 0.29.1 */
+/* 0.30.1 */
 import { NumericValue } from '../numeric-value/types';
-import type { BoxedExpression, ComputeEngine } from '../global-types';
+import type { Rational } from '../numerics/types';
 /**
  * Group terms in a product by common term.
  *

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

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

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

@@ -1,3 +1,3 @@
-/* 0.29.1 */
+/* 0.30.1 */
 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,6 +1,46 @@
-/* 0.29.1 */
+/* 0.30.1 */
 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,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality
@@ -15,4 +15,6 @@ export declare function findUnivariateRoots(expr: BoxedExpression, x: string): R
  * `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,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare class Terms {
     private engine;
     private terms;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 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;

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

@@ -1,32 +1,30 @@
-/* 0.29.1 */
+/* 0.30.1 */
 import { Type } from '../../common/type/types';
-import { NumericValue } from '../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 isLatexString(s: unknown): s is string;
-export declare function asLatexString(s: unknown): string | null;
 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 an identifier that is declared with a `Declare`
+ * A local variable is a symbol that is declared with a `Declare`
  * expression in a `Block` expression.
  *
- * Note that the canonical form of a `Block` expression will hoist all
- * `Declare` expressions to the top of the block. `Assign` expressions
- * of undeclared variables will also have a matching `Declare` expressions
- * hoisted.
+ */
+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 isRelationalOperator(name: BoxedExpression | string): boolean;
-export declare function isInequalityOperator(operator: string): boolean;
-export declare function isEquationOperator(operator: string): boolean;
-export declare function isInequality(expr: BoxedExpression): boolean;
-export declare function isEquation(expr: BoxedExpression): boolean;
+export declare function canonicalAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
 /**
  * Return a multiple of the imaginary unit, e.g.
  * - 'ImaginaryUnit'  -> 1
@@ -38,17 +36,19 @@ export declare function isEquation(expr: BoxedExpression): boolean;
  *
  */
 export declare function getImaginaryFactor(expr: number | BoxedExpression): BoxedExpression | undefined;
-export declare function normalizeFlags(flags: Partial<NumericFlags> | undefined): NumericFlags | undefined;
-export declare function isSymbolDefinition(def: any): def is SymbolDefinition;
-export declare function isFunctionDefinition(def: any): def is FunctionDefinition;
-export declare function semiCanonical(ce: ComputeEngine, xs: ReadonlyArray<SemiBoxedExpression>): ReadonlyArray<BoxedExpression>;
-export declare function canonical(ce: ComputeEngine, xs: ReadonlyArray<SemiBoxedExpression>): ReadonlyArray<BoxedExpression>;
-export declare function domainToType(expr: BoxedExpression): Type;
 /**
- * Return the angle in the range [0, 2π) that is equivalent to the given angle.
+ * `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.
  *
- * @param x
+ * @export
+ * @param expr
  * @returns
  */
-export declare function canonicalAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
+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,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 import type { BoxedExpression, ComputeEngine } from '../global-types';
 /**
  * Check that the number of arguments is as expected.
@@ -46,3 +46,4 @@ export declare function checkPure(ce: ComputeEngine, arg: BoxedExpression | Boxe
  *
  */
 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,70 +1,35 @@
-/* 0.29.1 */
+/* 0.30.1 */
 /** 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
+ * 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 isFiniteCollection(col: BoxedExpression): boolean;
-export declare function isIndexableCollection(col: BoxedExpression): boolean;
-export declare function isFiniteIndexableCollection(col: BoxedExpression): boolean;
-/**
- *
- * Iterate over all the elements of a collection. If not a collection,
- * return the expression.
- *
- * The `col` argument is either a collection literal, or a symbol
- * whose value is a collection literal.
- *
- * Even infinite collections are iterable. Use `isFiniteCollection()`
- * to check if the collection is finite.
- *
- * The collection can have one of the following forms:
- * - `["Range"]`, `["Interval"]`, `["Linspace"]` expressions
- * - `["List"]` and `["Set"]` expressions
- * - `["Tuple"]`, `["Pair"]`, `["Pair"]`, `["Triple"]` expressions
- * - `["Sequence"]` expressions
- * ... and more
- *
- * In general, `each` is easier to use than `iterator`, but they do the same
- * thing.
- *
- * @param col - A potential collection
- *
- * @returns
- */
-export declare function each(col: BoxedExpression): Generator<BoxedExpression>;
-/**
- *
- * The `col` argument is either a collection literal, or a symbol
- * whose value is a collection literal.
- *
- * @returns
- */
-export declare function length(col: BoxedExpression): number | undefined;
+export declare function isFiniteIndexedCollection(col: BoxedExpression): boolean;
+export declare function repeat(value: BoxedExpression, count?: number): Iterator<BoxedExpression>;
 /**
- * From an expression, create an iterator that can be used
- * to enumerate values.
- *
- * `expr` should be a collection expression, or a string, or a symbol whose
- * value is a collection expression or a string.
- *
- * - ["Range", 5]
- * - ["List", 1, 2, 3]
- * - "'hello world'"
- *
+ * 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 iterator(expr: BoxedExpression): Iterator<BoxedExpression> | undefined;
-export declare function repeat(value: BoxedExpression, count?: number): Iterator<BoxedExpression>;
+export declare function zip(items: ReadonlyArray<BoxedExpression>): Iterator<BoxedExpression[]>;
 /**
+ * Default collection handlers suitable for collections that store their
+ * elements as operands.
  *
- * @param expr
- * @param index 1-based index
- * @returns
+ * This is the case for List, Tuple, etc.
  */
-export declare function at(expr: BoxedExpression, index: number): BoxedExpression | undefined;
-export declare function defaultCollectionHandlers(def: undefined | Partial<CollectionHandlers>): Partial<CollectionHandlers> | undefined;
-export declare function zip(items: ReadonlyArray<BoxedExpression>): Iterator<BoxedExpression[]>;
+export declare function basicIndexedCollectionHandlers(): CollectionHandlers;
+export declare function defaultCollectionHandlers(def: undefined | CollectionHandlers): CollectionHandlers | undefined;

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

@@ -1,17 +1,20 @@
-/* 0.29.1 */
-import { BoxedExpression, CompiledType, JSSource } from './global-types';
-export type CompiledOperators = Record<MathJsonIdentifier, [
+/* 0.30.1 */
+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: MathJsonIdentifier]: CompiledFunction;
+    [id: MathJsonSymbol]: CompiledFunction;
 };
 export type CompileTarget = {
-    operators?: (op: MathJsonIdentifier) => [op: string, prec: number];
-    functions?: (id: MathJsonIdentifier) => CompiledFunction | undefined;
-    var: (id: MathJsonIdentifier) => string | undefined;
+    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;
@@ -21,9 +24,57 @@ export type CompileTarget = {
 /** 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 {
-    private sys;
+    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 function compileToTarget(expr: BoxedExpression, target: CompileTarget): (_?: Record<string, CompiledType>) => CompiledType;
-export declare function compileToJavascript(expr: BoxedExpression, functions?: Record<MathJsonIdentifier, JSSource | Function>, vars?: Record<MathJsonIdentifier, JSSource>, imports?: unknown[], preamble?: string): (_?: Record<string, CompiledType>) => CompiledType;
+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,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 /**
  * 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,18 +1,14 @@
-/* 0.29.1 */
+/* 0.30.1 */
+import type { BoxedDefinition, BoxedExpression, ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS
  *
- * A `["Function"]` expression has its own scope.
- * This scope includes the parameters and local variables.
+ * 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", ["Add", "_", 1], "_"]`).
- *
- * The **body** of a `["Function"]` expression may have its own scope
- * (for example if it's a `["Block"]` expression) or may not have a scope
- * at all (if it's a number, i.e. `["Function", 1]`). the function body may
- * be a number, a symbol or (more commonly) an function expression.
+ * (e.g. `["Function", ["Block", ["Add", "_", 1]], "_"]`).
  *
  *
  * #### DURING BOXING (in makeLambda())
@@ -32,11 +28,10 @@
  *
  * 1/ The arguments are evaluated in the current scope
  * 2/ The context is swapped to the function scope
- * 3/ The values of all the ids in this scope are reset
- * 4/ The parameters are set to the value of the arguments
- * 5/ The function body is evaluated in the context of the function scope
- * 6/ The context is swapped back to the current scope
- * 7/ The result of the function body is returned
+ * 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
  *
  */
 /**
@@ -48,28 +43,48 @@ export declare function predicate(_expr: BoxedExpression): (...args: BoxedExpres
  */
 export declare function order(_expr: BoxedExpression): (a: BoxedExpression, b: BoxedExpression) => -1 | 0 | 1;
 /**
- * Given an expression, rewrite it to a canonical Function form.
+ * 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"]
  *
- * - explicit parameters (no change)
- *      ["Function", ["Add, "x", 1], "x"]
- *      -> ["Function", ["Add, "x", 1], "x"]
  *
  * - single anonymous parameters:
  *      ["Add", "_", 1]
- *      -> ["Function", ["Add", "_", 1], "_"]
+ *      -> ["Function", ["Block", ["Add", "_", 1]], "_"]
  *
  * - multiple anonymous parameters:
  *      ["Add", "_1", "_2"]
- *      -> ["Function", ["Add", "_1", "_2"], "_1", "_2"]
+ *      -> ["Function", ["Block", ["Add", "_1", "_2"]], "_1", "_2"]
  *
  *
  */
-export declare function canonicalFunctionExpression(body: BoxedExpression, args?: BoxedExpression[]): [body: BoxedExpression, ...params: string[]];
+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
- * - an expression with anonymous parameters, e.g. ["Add", "_", 1]
- * - the identifier for a function, e.g. "Sin".
+ * 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;
 /**
@@ -89,15 +104,17 @@ export declare function makeLambdaN1(expr: BoxedExpression): ((arg: number) => n
  */
 export declare function applicable(fn: BoxedExpression): (xs: ReadonlyArray<BoxedExpression>) => BoxedExpression | undefined;
 /**
- * Use applicableN when the function is known to be a function of a single
- * variable and the argument is a number.
+ * Use `applicableN1()` when the function is known to be a function with a
+ * single real argument that returns a real value.
  *
- * Unlike "apply", applicable returns a function  that can be called
+ * Unlike `apply()`, `applicableN1()` returns a function that can be called
  * with an argument.
  *
  */
 export declare function applicableN1(fn: BoxedExpression): (x: number) => number;
 /**
- * Give a string like "f(x,y)" return, ["f", ["x", "y"]]
+ * 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;