@cortex-js/compute-engine 0.25.1 → 0.26.2

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

@@ -1,3 +1,5 @@
-/* 0.25.1 */
-export declare const version = "0.25.1";
+/* 0.26.2 */
+export declare const version = "0.26.2";
 export { ComputeEngine } from './compute-engine/compute-engine';
+export { terminal } from './common/terminal';
+export { highlightCodeSpan, highlightCodeBlock, } from './common/syntax-highlighter';

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

@@ -0,0 +1,11 @@
+/* 0.26.2 */
+ * Return true if the string is a valid identifier.
+ *
+ * Check for identifiers matching a profile of [Unicode UAX31](https://unicode.org/reports/tr31/)
+ *
+ * See https://cortexjs.io/math-json/#identifiers for a full definition of the
+ * profile.
+ */
+export declare function isValidIdentifier(s: string): boolean;
+export declare const EMOJIS: RegExp;
+export declare function validateIdentifier(s: unknown): 'valid' | 'not-a-string' | 'empty-string' | 'expected-nfc' | 'unexpected-mixed-emoji' | 'unexpected-bidi-marker' | 'unexpected-script' | 'invalid-first-char' | 'invalid-char';

package/dist/types/math-json/{math-json-format.d.ts → types.d.ts}

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 /** @category MathJSON */
 export type Attributes = {
     /** A human readable string to annotate this expression, since JSON does not
@@ -96,14 +96,9 @@ export type MathJsonString = {
 } & Attributes;
 /** @category MathJSON */
 export type MathJsonFunction = {
-    fn: [MathJsonIdentifier | MathJsonFunction, ...Expression[]];
-} & Attributes;
-/** @category MathJSON */
-export type MathJsonDictionary = {
-    dict: {
-        [key: string]: Expression;
-    };
+    fn: [MathJsonIdentifier, ...Expression[]];
 } & Attributes;
+export type ExpressionObject = MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction;
 /**
  * A MathJSON expression is a recursive data structure.
  *
@@ -112,4 +107,4 @@ export type MathJsonDictionary = {
  *
  * @category MathJSON
  */
-export type Expression = number | MathJsonIdentifier | string | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | [MathJsonIdentifier | MathJsonFunction, ...Expression[]];
+export type Expression = ExpressionObject | number | MathJsonIdentifier | string | readonly [MathJsonIdentifier, ...Expression[]];

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

@@ -1,14 +1,10 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const MISSING: Expression;
 export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumber;
 export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumber;
 export declare function isSymbolObject(expr: Expression | null): expr is MathJsonSymbol;
 export declare function isStringObject(expr: Expression | null): expr is MathJsonString;
 export declare function isFunctionObject(expr: Expression | null): expr is MathJsonFunction;
-export declare function isDictionaryObject(expr: Expression): expr is MathJsonNumber;
-export declare function isValidIdentifier(s: string): boolean;
-export declare const ONLY_EMOJIS: RegExp;
-export declare function validateIdentifier(s: unknown): 'valid' | 'not-a-string' | 'empty-string' | 'expected-nfc' | 'unexpected-mixed-emoji' | 'unexpected-bidi-marker' | 'unexpected-script' | 'invalid-first-char' | 'invalid-char';
 /**  If expr is a string literal, return it.
  *
  * A string literal is a JSON string that begins and ends with
@@ -17,30 +13,26 @@ export declare function validateIdentifier(s: unknown): 'valid' | 'not-a-string'
 export declare function stringValue(expr: Expression | null | undefined): string | null;
 export declare function stripText(expr: Expression | null | undefined): Expression | null;
 /**
- * The head of a function can be an identifier or an expression.
+ * The operator of a function is an identifier
  *
- * Return `null` if the expression is not a function.
+ * Return an empty string if the expression is not a function.
  *
  * Examples:
  * * `["Negate", 5]`  -> `"Negate"`
- * * `[["Prime", "f"], "x"]` -> `["Prime", "f"]`
  */
-export declare function head(expr: Expression | null | undefined): Expression | null;
-/** Return the head of an expression, only if it's a string */
-export declare function headName(expr: Expression | null): string;
+export declare function operator(expr: Expression | null | undefined): MathJsonIdentifier;
 /**
- * Return all the elements but the first one, i.e. the arguments of a
- * function.
+ * Return the arguments of a function, or an empty array if not a function
+ * or no arguments.
  */
-export declare function ops(expr: Expression | null | undefined): Expression[] | null;
-/** Return the nth argument of a function expression */
-export declare function op(expr: Expression | null | undefined, n: number): Expression | null;
-export declare function op1(expr: Expression | null | undefined): Expression | null;
-export declare function op2(expr: Expression | null | undefined): Expression | null;
+export declare function operands(expr: Expression | null | undefined): ReadonlyArray<Expression>;
+/** Return the nth operand of a function expression */
+export declare function operand(expr: Expression | null, n: 1 | 2 | 3): Expression | null;
 export declare function nops(expr: Expression | null | undefined): number;
-export declare function unhold(expr: Expression | null | undefined): Expression | null;
+export declare function unhold(expr: Expression | null): Expression | null;
 export declare function symbol(expr: Expression | null | undefined): string | null;
 export declare function dictionary(expr: Expression | null): null | Record<string, Expression>;
+export declare function dictionaryFrom(dict: Record<string, Expression>): Expression;
 /**
  *  CAUTION: `machineValue()` will return a truncated value if the number
  *  has a precision outside of the machine range.
@@ -59,7 +51,6 @@ export declare function machineValue(expr: Expression | null | undefined): numbe
  * The denominator is always > 0.
  */
 export declare function rationalValue(expr: Expression | undefined | null): [number, number] | null;
-export declare function applyRecursively<T extends Expression = Expression>(expr: T, fn: (x: T) => T): Expression;
 export declare function subs(expr: Expression, s: {
     [symbol: string]: Expression;
 }): Expression;
@@ -73,8 +64,9 @@ export declare function mapArgs<T>(expr: Expression, fn: (x: Expression) => T):
  */
 export declare function foldAssociativeOperator(op: string, lhs: Expression, rhs: Expression): Expression;
 /** Return the elements of a sequence, or null if the expression is not a sequence. The sequence can be optionally enclosed by a`["Delimiter"]` expression  */
-export declare function getSequence(expr: Expression | null): Expression[] | null;
-export declare function isEmptySequence(expr: Expression | null): boolean;
-export declare function missingIfEmpty(expr: Expression | null): Expression;
+export declare function getSequence(expr: Expression | null | undefined): ReadonlyArray<Expression> | null;
+/** `Nothing` or the empty sequence (`["Sequence"]`) */
+export declare function isEmptySequence(expr: Expression | null | undefined): expr is null | undefined;
+export declare function missingIfEmpty(expr: Expression | null | undefined): Expression;
 /** The number of leaves (atomic expressions) in the expression */
 export declare function countLeaves(expr: Expression | null): number;

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

@@ -1,3 +1,3 @@
-/* 0.25.1 */
-export { isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, } from './math-json/utils';
-export declare const version = "0.25.1";
+/* 0.26.2 */
+export { isSymbolObject, isStringObject, isFunctionObject, stringValue as getStringValue, operator, operand, symbol, mapArgs, dictionary as getDictionary, } from './math-json/utils';
+export declare const version = "0.26.2";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.25.1",
+  "version": "0.26.2",
   "scripts": {
     "doc": "bash ./scripts/doc.sh",
     "build": "bash ./scripts/build.sh",
@@ -66,7 +66,7 @@
     "chalk": "^5.3.0",
     "check-node-version": "^4.2.1",
     "concat-md": "^0.5.1",
-    "esbuild": "^0.21.5",
+    "esbuild": "^0.24.0",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-import": "^2.28.1",
@@ -88,7 +88,7 @@
   },
   "prettier": "@cortex-js/prettier-config",
   "dependencies": {
-    "complex.js": "^2.1.1",
+    "complex-esm": "^2.1.1-esm1",
     "decimal.js": "^10.4.3"
   }
 }

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

@@ -1,48 +0,0 @@
-/* 0.25.1 */
-import Decimal from 'decimal.js';
-import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, ReplaceOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, BoxedSubstitution, Rule, CanonicalOptions } from './public';
-import { _BoxedExpression } from './abstract-boxed-expression';
-/**
- * BoxedDictionary
- *
- * @noInheritDoc
- */
-export declare class BoxedDictionary extends _BoxedExpression {
-    private _value;
-    private _isCanonical;
-    constructor(ce: IComputeEngine, dict: {
-        [key: string]: SemiBoxedExpression;
-    } | Map<string, BoxedExpression>, options?: {
-        canonical?: CanonicalOptions;
-        metadata?: Metadata;
-    });
-    bind(): void;
-    reset(): undefined;
-    get hash(): number;
-    get complexity(): number;
-    get head(): 'Dictionary';
-    get isPure(): boolean;
-    getKey(key: string): BoxedExpression | undefined;
-    hasKey(key: string): boolean;
-    get keys(): IterableIterator<string>;
-    get keysCount(): number;
-    has(x: string | string[]): boolean;
-    get domain(): BoxedDomain;
-    get json(): Expression;
-    /** Structural equality */
-    isSame(rhs: BoxedExpression): boolean;
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    /** Mathematical equality */
-    isEqual(rhs: BoxedExpression): boolean;
-    evaluate(_options?: EvaluateOptions): BoxedExpression;
-    get isCanonical(): boolean;
-    set isCanonical(val: boolean);
-    get canonical(): BoxedExpression;
-    simplify(_options?: SimplifyOptions): BoxedExpression;
-    N(_options?: NOptions): BoxedExpression;
-    replace(rules: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): null | BoxedExpression;
-    subs(sub: Substitution, options?: {
-        canonical?: CanonicalOptions;
-    }): BoxedExpression;
-}

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

@@ -1,40 +0,0 @@
-/* 0.25.1 */
-import Decimal from 'decimal.js';
-import { Expression } from '../../math-json/math-json-format';
-import { BoxedDomain, BoxedSubstitution, DomainCompatibility, DomainConstructor, DomainExpression, DomainLiteral, IComputeEngine, Metadata, PatternMatchOptions } from '../public';
-import { _BoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, SemiBoxedExpression } from './public';
-/**
- * A `_BoxedDomain` is a wrapper around a boxed, canonical, domain
- * expression.
- *
- * It could be an invalid domain, in which case `isValid` is `false`.
- *
- * @noInheritDoc
- */
-export declare class _BoxedDomain extends _BoxedExpression implements BoxedDomain {
-    private _hash;
-    readonly base: DomainLiteral;
-    readonly ctor: DomainConstructor | null;
-    readonly params: DomainExpression<Expression>[];
-    constructor(ce: IComputeEngine, dom: DomainExpression, metadata?: Metadata);
-    /** Boxed domains are always canonical. */
-    get isCanonical(): boolean;
-    get canonical(): _BoxedDomain;
-    get isValid(): boolean;
-    get json(): Expression;
-    get hash(): number;
-    isCompatible(dom: BoxedDomain | DomainLiteral, compatibility?: DomainCompatibility): boolean;
-    isEqual(rhs: BoxedExpression): boolean;
-    isSame(rhs: BoxedExpression): boolean;
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
-    get head(): string;
-    get domain(): BoxedDomain;
-    get isFunction(): boolean;
-    get isNumeric(): boolean;
-}
-/** Validate that `expr` is a Domain */
-export declare function isDomain(expr: Expression | BoxedExpression | BoxedDomain | DomainExpression): expr is BoxedDomain | DomainExpression;
-/** Return the ancestor domain (Least Upper Bound) that is shared by both `a` and `b` */
-export declare function widen(a: BoxedDomain | undefined | null, b: BoxedDomain | undefined | null): BoxedDomain | undefined;
-export declare function narrow(a: BoxedDomain | undefined, b: BoxedDomain | undefined): BoxedDomain;

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

@@ -1,56 +0,0 @@
-/* 0.25.1 */
- *
- * ## THEORY OF OPERATIONS
- *
- * In order to preserve exact results, some numeric operations are performed
- * on "coefficients" which represent a product of a rational number,
- * an algebraic numbers and the square root of an integer.
- *
- * A field is defined on these coefficients.
- *
- *
- */
-import { Rational } from '../numerics/rationals';
-import { BoxedExpression } from './public';
-export interface CoefficientData {
-    float: number;
-    rational: Rational;
-    sqrt: number;
-}
-export declare class Coefficient implements CoefficientData {
-    static zero: Coefficient;
-    static one: Coefficient;
-    /**
-     * Attempt to factor a numeric coefficient `c` and a `rest` out of a
-     * canonical expression `expr` such that `ce.mul(c, rest)` is equal to `expr`.
-     *
-     * Attempts to make `rest` a positive value (i.e. pulls out negative sign).
-     *
-     * For example:
-     *
-     * ['Multiply', 2, 'x', 3, 'a']
-     *    -> [6, ['Multiply', 'x', 'a']]
-     *
-     * ['Divide', ['Multiply', 2, 'x'], ['Multiply', 3, 'y', 'a']]
-     *    -> [['Rational', 2, 3], ['Divide', 'x', ['Multiply, 'y', 'a']]]
-     */
-    static fromExpression(expr: BoxedExpression): [coef: Coefficient, rest: BoxedExpression];
-    float: number;
-    rational: Rational;
-    sqrt: number;
-    constructor(value?: number | Partial<CoefficientData>);
-    asFloat(): number;
-    asRational(): Rational;
-    normalize(): void;
-    get isZero(): boolean;
-    get isOne(): boolean;
-    get sign(): number;
-    neg(): Coefficient;
-    inv(): Coefficient;
-    mul(other: Partial<CoefficientData> | number | Rational): Coefficient;
-    pow(exponent: number): Coefficient;
-    div(other: Partial<CoefficientData> | number | Rational): Coefficient;
-    add(other: Partial<CoefficientData> | number | Rational): Coefficient;
-    sub(other: Partial<CoefficientData> | number | Rational): Coefficient;
-    eq(other: Coefficient): boolean;
-}

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

@@ -1,19 +0,0 @@
-/* 0.25.1 */
-import { Decimal } from 'decimal.js';
-import { Rational } from './numerics/rationals';
-import type { BoxedDomain, BoxedFunctionSignature, DomainLiteral, FunctionSignature, IComputeEngine } from './public';
-/**
- * Determine the numeric domain of a number.
- */
-export declare function inferNumericDomain(value: number | Decimal | Complex | Rational): DomainLiteral;
-/**
- * Extract the parts of a function domain.
- */
-export declare function functionDomain(dom: BoxedDomain): [
-    params: BoxedDomain[],
-    optParams: BoxedDomain[],
-    restParam: BoxedDomain | undefined,
-    result: BoxedDomain
-];
-export declare function domainToSignature(dom: BoxedDomain): Partial<FunctionSignature>;
-export declare function signatureToDomain(ce: IComputeEngine, sig: BoxedFunctionSignature): BoxedDomain;

package/dist/types/compute-engine/library/arithmetic-add.d.ts

@@ -1,21 +0,0 @@
-/* 0.25.1 */
-/** The canonical form of `Add`:
- * - removes `0`
- * - capture complex numbers (a + ib or ai +b)
- * */
-export declare function canonicalAdd(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function domainAdd(_ce: IComputeEngine, args: (undefined | BoxedDomain)[]): BoxedDomain | null | undefined;
-export declare function simplifyAdd(ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function evalAdd(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, mode?: 'N' | 'evaluate'): BoxedExpression;
-export declare function canonicalSummation(ce: IComputeEngine, body: BoxedExpression, indexingSet: BoxedExpression | undefined): BoxedExpression | null;
-export declare function evalSummation(ce: IComputeEngine, summationEquation: ReadonlyArray<BoxedExpression>, mode: 'simplify' | 'N' | 'evaluate'): 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 getImaginaryCoef(expr: BoxedExpression): number;

package/dist/types/compute-engine/library/arithmetic-divide.d.ts

@@ -1,16 +0,0 @@
-/* 0.25.1 */
-/**
- * Canonical form of 'Divide' (and 'Rational')
- * - remove denominator of 1
- * - simplify the signs
- * - factor out negate (make the numerator and denominator positive)
- * - if numerator and denominator are integer literals, return a rational number
- *   or Rational experssion
- */
-export declare function canonicalDivide(ce: IComputeEngine, op1: BoxedExpression, op2: BoxedExpression): BoxedExpression;
-/**
- * Simplify form of 'Divide' (and 'Rational')
- */
-export declare function simplifyDivide(ce: IComputeEngine, op1: BoxedExpression, op2: BoxedExpression): BoxedExpression | undefined;
-export declare function evalDivide(ce: IComputeEngine, op1: BoxedExpression, op2: BoxedExpression): BoxedExpression;
-export declare function evalNDivide(ce: IComputeEngine, op1: BoxedExpression, op2: BoxedExpression): BoxedExpression;

package/dist/types/compute-engine/library/arithmetic-multiply.d.ts

@@ -1,16 +0,0 @@
-/* 0.25.1 */
-/** The canonical form of `Multiply`:
- * - remove `1`
- * - simplify the signs:
- *    - i.e. `-y \times -x` -> `x \times y`
- *    - `2 \times -x` -> `-2 \times x`
- * - arguments are sorted
- * - complex numbers promoted (['Multiply', 2, 'ImaginaryUnit'] -> 2i)
- *
- * The ops must be canonical, the result is canonical.
- */
-export declare function canonicalMultiply(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function simplifyMultiply(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function evalMultiply(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, mode?: 'N' | 'evaluate'): BoxedExpression;
-export declare function canonicalProduct(ce: IComputeEngine, body: BoxedExpression | undefined, indexingSet: BoxedExpression | undefined): BoxedExpression | null;
-export declare function evalMultiplication(ce: IComputeEngine, summationEquation: ReadonlyArray<BoxedExpression>, mode: 'simplify' | 'N' | 'evaluate'): BoxedExpression | undefined;

package/dist/types/compute-engine/library/arithmetic-power.d.ts

@@ -1,11 +0,0 @@
-/* 0.25.1 */
-import { BoxedExpression, IComputeEngine, Metadata } from '../public';
-/**
- *
- */
-export declare function canonicalPower(ce: IComputeEngine, base: BoxedExpression, exponent: BoxedExpression, metadata?: Metadata): BoxedExpression;
-export declare function square(ce: IComputeEngine, base: BoxedExpression): BoxedExpression;
-export declare function processPower(ce: IComputeEngine, base: BoxedExpression, exponent: BoxedExpression, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;
-export declare function processSqrt(ce: IComputeEngine, base: BoxedExpression, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;
-export declare function isSqrt(expr: BoxedExpression): boolean;
-export declare function asRationalSqrt(expr: BoxedExpression): Rational | null;

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

@@ -1,16 +0,0 @@
-/* 0.25.1 */
-export declare const DOMAIN_CONSTRUCTORS: string[];
-export declare const DOMAIN_ALIAS: {
-    Functions: (string | string[])[];
-    NumericFunctions: (string | string[])[];
-    RealFunctions: (string | string[])[];
-    LogicOperators: (string | string[])[];
-    Predicates: (string | string[])[];
-    RelationalOperators: string[];
-};
-export declare function isDomainLiteral(s: string | null): s is DomainLiteral;
-export declare function isSubdomainLiteral(lhs: string, rhs: string): boolean;
-/** Return all the domain literals that are an ancestor of `dom`
- */
-export declare function ancestors(dom: DomainLiteral): DomainLiteral[];
-export declare function domainSetsLibrary(): IdentifierDefinitions;

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

@@ -1,17 +0,0 @@
-/* 0.25.1 */
-import { Rational } from './rationals';
-export declare class Terms {
-    private engine;
-    private terms;
-    constructor(ce: IComputeEngine, terms: ReadonlyArray<BoxedExpression>);
-    sub(term: BoxedExpression): void;
-    add(term2: BoxedExpression, coef2?: Rational): void;
-    find(term: BoxedExpression): number;
-    /** If `exact` is true, keep exact numbers */
-    reduceNumbers({ exact }: {
-        exact: boolean;
-    }): void;
-    asExpression(options: {
-        exact: boolean;
-    }): BoxedExpression;
-}

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

@@ -1,20 +0,0 @@
-/* 0.25.1 */
-/**
- * For each rules in the rule set that match, return the `replace` of the rule
- *
- * @param rules
- */
-export declare function matchRules(expr: BoxedExpression, rules: BoxedRuleSet, sub: BoxedSubstitution): BoxedExpression[];
-/**
- * Create a boxed rule set from a non-boxed rule set
- * @param ce
- * @param rs
- * @returns
- */
-export declare function boxRules(ce: IComputeEngine, rs: Iterable<Rule>): BoxedRuleSet;
-/**
- * Apply the rules in the ruleset and return a modified expression.
- *
- * If no rule applied, return `null`.
- */
-export declare function replace(expr: BoxedExpression, ruleSet: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): BoxedExpression | null;

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

@@ -1,23 +0,0 @@
-/* 0.25.1 */
-export declare function distribute(expr: ReadonlyArray<BoxedExpression>): BoxedExpression;
-/** Use the multinomial theorem (https://en.wikipedia.org/wiki/Multinomial_theorem) to expand the expression.
- * The expression must be a power of a sum of terms.
- * The power must be a positive integer.
- * - expr = '(a + b)^2'
- *     ->  'a^2 + 2ab + b^2'
- * - expr = '(a + b)^3'
- *    -> 'a^3 + 3a^2b + 3ab^2 + b^3'
- */
-export declare function expandMultinomial(expr: BoxedExpression): BoxedExpression | null;
-/** Expand all
- * Recursive expand of all terms in the expression
- */
-export declare function expandAll(expr: BoxedExpression): BoxedExpression | null;
-/** Apply the distributive law if the expression is a product of sums.
- * For example, a(b + c) = ab + ac
- * Expand the expression if it is a power of a sum.
- * Expand the terms of the expression if it is a sum or negate.
- * If the expression is a fraction, expand the numerator.
- * Return null if the expression cannot be expanded.
- */
-export declare function expand(expr: BoxedExpression | undefined): BoxedExpression | null;

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

@@ -1,9 +0,0 @@
-/* 0.25.1 */
-/**
- * Flatten the arguments.
- */
-export declare function flattenOps(ops: ReadonlyArray<BoxedExpression>, head: string): ReadonlyArray<BoxedExpression>;
-/**
- * @todo: this function should probably not be recursive. As it, it is semi-recursive.
- */
-export declare function flattenSequence(xs: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;

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

@@ -1,22 +0,0 @@
-/* 0.25.1 */
-import { Decimal } from 'decimal.js';
-import { Rational } from '../numerics/rationals';
-import { BoxedExpression, Hold, IComputeEngine, SemiBoxedExpression } from '../public';
-/**
- * Return a rational coef and constant such that `coef * mod + constant = expr`
- */
-/**
- * Return a coef, term and constant such that:
- *
- * `coef * term + constant = expr`
- *
- * Return null if no `coef`/`constant` can be found.
- */
-export declare function makePositive(expr: BoxedExpression): [sign: number, expr: BoxedExpression];
-export declare function apply(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): number | Decimal | Complex;
-export declare function applyN(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): BoxedExpression | undefined;
-export declare function apply2(expr1: BoxedExpression, expr2: BoxedExpression, fn: (x1: number, x2: number) => number | Complex | Rational, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | Rational | number, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): number | Decimal | Complex | Rational;
-export declare function apply2N(expr1: BoxedExpression, expr2: BoxedExpression, fn: (x1: number, x2: number) => number | Complex | Rational, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | number | Rational, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): BoxedExpression | undefined;
-export declare function shouldHold(skip: Hold, count: number, index: number): boolean;
-export declare function semiCanonical(ce: IComputeEngine, xs: ReadonlyArray<SemiBoxedExpression>): ReadonlyArray<BoxedExpression>;
-export declare function canonical(xs: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;