@cortex-js/compute-engine 0.25.1 → 0.26.2

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

@@ -0,0 +1,129 @@
+/* 0.26.2 */
+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: IComputeEngine, 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. @fixme: account for options.canonical
+ *
+ */
+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 +1,3 @@
-/* 0.25.1 */
-import { BoxedExpression, IComputeEngine, JsonSerializationOptions } from '../public';
+/* 0.26.2 */
+import type { BoxedExpression, IComputeEngine, JsonSerializationOptions } from '../public';
 export declare function serializeJson(ce: IComputeEngine, expr: BoxedExpression, options: Readonly<JsonSerializationOptions>): Expression;

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

@@ -0,0 +1,6 @@
+/* 0.26.2 */
+export declare function sgn(expr: BoxedExpression): Sign | undefined;
+export declare function positiveSign(s: Sign | undefined): boolean | undefined;
+export declare function nonNegativeSign(s: Sign | undefined): boolean | undefined;
+export declare function negativeSign(s: Sign | undefined): boolean | undefined;
+export declare function nonPositiveSign(s: Sign | undefined): boolean | undefined;

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

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

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

@@ -1,5 +1,5 @@
-/* 0.25.1 */
-import { Rule } from './public';
+/* 0.26.2 */
+import { Rule } from '../public';
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality
@@ -8,12 +8,12 @@ export declare const UNIVARIATE_ROOTS: Rule[];
  *
  */
 export declare function findUnivariateRoots(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression>;
-/** Expr is an equation with a head of
+/** Expr is an equation with an operator of
  * - `Equal`, `Less`, `Greater`, `LessEqual`, `GreaterEqual`
  *
- * Return an expression with the same head, but with the first argument
+ * 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<SemiBoxedExpression> | null;
+export declare function univariateSolve(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression> | null;
 export declare const HARMONIZATION_RULES: Rule[];

package/dist/types/compute-engine/{symbolic → boxed-expression}/tensor-fields.d.ts

@@ -1,5 +1,5 @@
-/* 0.25.1 */
-import { BoxedExpression, IComputeEngine } from '../public';
+/* 0.26.2 */
+import type { BoxedExpression, IComputeEngine } from '../public';
 export type DataTypeMap = {
     float64: number;
     float32: number;
@@ -164,5 +164,5 @@ export declare class TensorFieldComplex implements TensorField<Complex> {
     pow(lhs: Complex, rhs: number): Complex;
     conjugate(z: Complex): Complex;
 }
-export declare function getSupertype(t1: TensorDataType, t2: TensorDataType): TensorDataType;
+export declare function getSupertype(t1: TensorDataType | undefined, t2: TensorDataType): TensorDataType;
 export declare function getExpressionDatatype(expr: BoxedExpression): TensorDataType;

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

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

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

@@ -0,0 +1,10 @@
+/* 0.26.2 */
+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: IComputeEngine, 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;
+export declare function canonicalAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;

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

@@ -1,28 +1,14 @@
-/* 0.25.1 */
-import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, IComputeEngine } from './public';
+/* 0.26.2 */
+import { Type } from '../../common/type/types';
 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: IComputeEngine): boolean;
-/** When result of a numeric evaluation is a complex number,
- * return `NaN` if not `complexallowed()`
- */
-export declare function complexAllowed(ce: IComputeEngine): 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;
-/**
- * If `expr` is a number, return it as a Decimal (it might be
- * in the machine value range or not). Use `isInMachineRange()` to check.
- *
- * Use this instead of `machineValue()` when possible, as `machineValue` will
- * truncate bignums to machine numbers
- */
-export declare function bignumValue(ce: IComputeEngine, expr: Expression | null | undefined): Decimal | null;
-export declare function asBigint(expr: BoxedExpression): bigint | null;
 export declare function normalizedUnknownsForSolve(syms: string | Iterable<string> | BoxedExpression | Iterable<BoxedExpression> | null | undefined): string[];
 /** Return the local variables in the expression.
  *
@@ -36,4 +22,24 @@ export declare function normalizedUnknownsForSolve(syms: string | Iterable<strin
  *
  */
 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;
+/**
+ * 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;
+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: IComputeEngine, xs: ReadonlyArray<SemiBoxedExpression>): ReadonlyArray<BoxedExpression>;
+export declare function canonical(ce: IComputeEngine, xs: ReadonlyArray<SemiBoxedExpression>): ReadonlyArray<BoxedExpression>;
+export declare function domainToType(expr: BoxedExpression): Type;

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

@@ -1,5 +1,6 @@
-/* 0.25.1 */
-import { BoxedExpression } from './public';
+/* 0.26.2 */
+import type { IComputeEngine } from '../public';
+import { Type } from '../../common/type/types';
 /**
  * Check that the number of arguments is as expected.
  *
@@ -18,23 +19,25 @@ export declare function checkArity(ce: IComputeEngine, ops: ReadonlyArray<BoxedE
  *
  * We also assume that the function is threadable.
  *
- * Converts the arguments to canonical, and flattens the sequence.
+ * The arguments are made canonical.
+ *
+ * Flattens sequence expressions.
  */
 export declare function checkNumericArgs(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, options?: number | {
     count?: number;
-    flatten?: boolean | string;
+    flatten?: string;
 }): ReadonlyArray<BoxedExpression>;
 /**
  * Check that an argument is of the expected domain.
  *
  * Converts the arguments to canonical
  */
-export declare function checkDomain(ce: IComputeEngine, arg: BoxedExpression | undefined | null, dom: BoxedDomain | DomainLiteral | undefined): BoxedExpression;
+export declare function checkType(ce: IComputeEngine, arg: BoxedExpression | undefined | null, type: Type | undefined): BoxedExpression;
+export declare function checkTypes(ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>, types: Type[]): ReadonlyArray<BoxedExpression>;
 /**
  * Check that the argument is pure.
  */
 export declare function checkPure(ce: IComputeEngine, arg: BoxedExpression | BoxedExpression | undefined | null): BoxedExpression;
-export declare function checkDomains(ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>, doms: (BoxedDomain | DomainLiteral)[]): ReadonlyArray<BoxedExpression>;
 /**
  *
  * If the arguments match the parameters, return null.
@@ -43,4 +46,4 @@ export declare function checkDomains(ce: IComputeEngine, args: ReadonlyArray<Box
  * arguments.
  *
  */
-export declare function adjustArguments(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, hold: Hold, threadable: boolean, params: BoxedDomain[], optParams: BoxedDomain[], restParam: BoxedDomain | undefined): ReadonlyArray<BoxedExpression> | null;
+export declare function validateArguments(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, def: BoxedFunctionDefinition): ReadonlyArray<BoxedExpression> | null;

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

@@ -1,5 +1,13 @@
-/* 0.25.1 */
-export declare function isCollection(col: BoxedExpression): boolean;
+/* 0.26.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 isFiniteCollection(col: BoxedExpression): boolean;
 export declare function isIndexableCollection(col: BoxedExpression): boolean;
 export declare function isFiniteIndexableCollection(col: BoxedExpression): boolean;
@@ -37,6 +45,19 @@ export declare function each(col: BoxedExpression): Generator<BoxedExpression>;
  * @returns
  */
 export declare function length(col: BoxedExpression): number | undefined;
+/**
+ * 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'"
+ *
+ */
+export declare function iterator(expr: BoxedExpression): Iterator<BoxedExpression> | undefined;
 /**
  *
  * @param expr
@@ -44,3 +65,4 @@ export declare function length(col: BoxedExpression): number | undefined;
  * @returns
  */
 export declare function at(expr: BoxedExpression, index: number): BoxedExpression | undefined;
+export declare function defaultCollectionHandlers(def: undefined | Partial<CollectionHandlers>): Partial<CollectionHandlers> | undefined;

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

@@ -1,5 +1,5 @@
-/* 0.25.1 */
-import { BoxedExpression } from './public';
+/* 0.26.2 */
+import type { BoxedExpression } from './public';
 export type CompiledType = boolean | number | string | object;
 type JSSource = string;
 export type CompiledOperators = Record<MathJsonIdentifier, [
@@ -22,7 +22,7 @@ export type CompileTarget = {
  * a custom scope for "global" functions. */
 export declare class ComputeEngineFunction extends Function {
     private sys;
-    constructor(body: any);
+    constructor(body: string);
 }
 export declare function compileToTarget(expr: BoxedExpression, target: CompileTarget): ((_: Record<string, CompiledType>) => CompiledType) | undefined;
 export declare function compileToJavascript(expr: BoxedExpression): ((_: Record<string, CompiledType>) => CompiledType) | undefined;