Interface IComputeEngineInternal

interface IComputeEngine {
    _BIGNUM_HALF: Decimal;
    _BIGNUM_NAN: Decimal;
    _BIGNUM_NEGATIVE_ONE: Decimal;
    _BIGNUM_ONE: Decimal;
    _BIGNUM_PI: Decimal;
    _BIGNUM_TWO: Decimal;
    _BIGNUM_ZERO: Decimal;
    Anything: BoxedDomain;
    bignum: ((a: bigint | Value) => Decimal);
    Booleans: BoxedDomain;
    complex: ((a: number | Complex, b?: number) => Complex);
    ComplexInfinity: BoxedExpression;
    context: null | RuntimeScope;
    costFunction: ((expr: BoxedExpression) => number);
    deadline?: number;
    E: BoxedExpression;
    False: BoxedExpression;
    Half: BoxedExpression;
    I: BoxedExpression;
    iterationLimit: number;
    latexDictionary: readonly LatexDictionaryEntry[];
    NaN: BoxedExpression;
    NegativeInfinity: BoxedExpression;
    NegativeOne: BoxedExpression;
    Nothing: BoxedExpression;
    Numbers: BoxedDomain;
    numericMode: NumericMode;
    One: BoxedExpression;
    Pi: BoxedExpression;
    PositiveInfinity: BoxedExpression;
    recursionLimit: number;
    stats: ComputeEngineStats;
    strict: boolean;
    Strings: BoxedDomain;
    timeLimit: number;
    tolerance: number;
    True: BoxedExpression;
    Void: BoxedDomain;
    Zero: BoxedExpression;
    get assumptions(): ExpressionMapInterface<boolean>;
    jsonSerializationOptions: Readonly<JsonSerializationOptions>;
    latexOptions: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
    precision: number;
    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
    _register(expr: BoxedExpression): void;
    _unregister(expr: BoxedExpression): void;
    add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
    array(elements: ArrayValue[] | ArrayValue[][], metadata?: Metadata): BoxedExpression;
    ask(pattern: SemiBoxedExpression): BoxedSubstitution[];
    assign(ids: {
        [id: string]: AssignValue;
    }): IComputeEngine;
    assign(id: string, value: AssignValue): IComputeEngine;
    assign(arg1: string | {
        [id: string]: AssignValue;
    }, arg2?: AssignValue): IComputeEngine;
    assume(predicate: SemiBoxedExpression): AssumeResult;
    box(expr: SemiBoxedExpression | [num: number, denom: number], options?: {
        canonical?: boolean | CanonicalForm | CanonicalForm[];
    }): BoxedExpression;
    cache<T>(name: string, build: (() => T), purge?: ((T: any) => undefined | T)): T;
    canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
    checkContinueExecution(): void;
    chop(n: number): number;
    chop(n: Decimal): 0 | Decimal;
    chop(n: Complex): 0 | Complex;
    chop(n: number | Decimal | Complex): number | Decimal | Complex;
    declare(identifiers: {
        [id: string]:
            | BoxedDomain
            | DomainExpression
            | SymbolDefinition
            | FunctionDefinition;
    }): IComputeEngine;
    declare(id: string, def:
        | SymbolDefinition
        | FunctionDefinition
        | BoxedDomain
        | DomainExpression<SemiBoxedExpression>): IComputeEngine;
    declare(arg1: string | {
        [id: string]:
            | BoxedDomain
            | DomainExpression
            | SymbolDefinition
            | FunctionDefinition;
    }, arg2?:
        | SymbolDefinition
        | FunctionDefinition
        | BoxedDomain
        | DomainExpression<SemiBoxedExpression>): IComputeEngine;
    defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
    defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
    div(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
    domain(domain: BoxedDomain | DomainExpression<SemiBoxedExpression>, metadata?: Metadata): BoxedDomain;
    domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
    error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
    fn(head: SemiBoxedExpression, ops: SemiBoxedExpression[], options?: {
        canonical: boolean;
    }): BoxedExpression;
    forget(symbol?: string | string[]): void;
    hold(expr: SemiBoxedExpression): BoxedExpression;
    inv(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
    isBignum(a: unknown): a is Decimal;
    isComplex(a: unknown): a is Complex;
    lookupFunction(head: string | BoxedExpression, scope?: null | RuntimeScope): undefined | BoxedFunctionDefinition;
    lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
    mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
    neg(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
    number(value:
        | string
        | number
        | bigint
        | Decimal
        | Complex
        | MathJsonNumber
        | Rational, options?: {
        canonical?: boolean;
        metadata?: Metadata;
    }): BoxedExpression;
    pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
    parse(s: string, options?: {
        canonical?: boolean | CanonicalForm | CanonicalForm[];
    }): BoxedExpression;
    parse(s: null, options?: {
        canonical?: boolean | CanonicalForm | CanonicalForm[];
    }): null;
    parse(s: null | string, options?: {
        canonical?: boolean | CanonicalForm | CanonicalForm[];
    }): null | BoxedExpression;
    pattern(expr: SemiBoxedExpression): Pattern;
    popScope(): IComputeEngine;
    pow(base: BoxedExpression, exponent: number | BoxedExpression | Rational, metadata?: Metadata): BoxedExpression;
    pushScope(scope?: Partial<Scope>): IComputeEngine;
    reset(): void;
    resetContext(): void;
    rules(rules: Rule[]): BoxedRuleSet;
    serialize(expr: SemiBoxedExpression, options?: {
        canonical?: boolean;
    }): string;
    shouldContinueExecution(): boolean;
    sqrt(base: BoxedExpression, metadata?: Metadata): BoxedExpression;
    string(s: string, metadata?: Metadata): BoxedExpression;
    swapScope(scope: null | RuntimeScope): null | RuntimeScope;
    symbol(sym: string, options?: {
        canonical?: boolean;
        metadata?: Metadata;
    }): BoxedExpression;
    tuple(elements: number[], metadata?: Metadata): BoxedExpression;
    tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
    verify(query: SemiBoxedExpression): boolean;
}

Implemented by

Properties

_BIGNUM_HALF _BIGNUM_NAN _BIGNUM_NEGATIVE_ONE _BIGNUM_ONE _BIGNUM_PI _BIGNUM_TWO _BIGNUM_ZERO Anything bignum Booleans complex ComplexInfinity context costFunction deadline? E False Half I iterationLimit latexDictionary NaN NegativeInfinity NegativeOne Nothing Numbers numericMode One Pi PositiveInfinity recursionLimit stats strict Strings timeLimit tolerance True Void Zero

Accessors

assumptions jsonSerializationOptions latexOptions precision

Methods

_fn _register _unregister add array ask assign assume box cache canonical checkContinueExecution chop declare defineFunction defineSymbol div domain domainError error fn forget hold inv isBignum isComplex lookupFunction lookupSymbol mul neg number pair parse pattern popScope pow pushScope reset resetContext rules serialize shouldContinueExecution sqrt string swapScope symbol tuple verify

Properties

Readonly Internal_BIGNUM_HALF

_BIGNUM_HALF: Decimal

Readonly Internal_BIGNUM_NAN

_BIGNUM_NAN: Decimal

Readonly Internal_BIGNUM_NEGATIVE_ONE

_BIGNUM_NEGATIVE_ONE: Decimal

Readonly Internal_BIGNUM_ONE

_BIGNUM_ONE: Decimal

Readonly Internal_BIGNUM_PI

_BIGNUM_PI: Decimal

Readonly Internal_BIGNUM_TWO

_BIGNUM_TWO: Decimal

Readonly Internal_BIGNUM_ZERO

_BIGNUM_ZERO: Decimal

ReadonlyAnything

Anything: BoxedDomain

bignum

bignum: ((a: bigint | Value) => Decimal)

ReadonlyBooleans

Booleans: BoxedDomain

complex

complex: ((a: number | Complex, b?: number) => Complex)

ReadonlyComplexInfinity

ComplexInfinity: BoxedExpression

context

context: null | RuntimeScope

The current scope

costFunction

costFunction: ((expr: BoxedExpression) => number)

Optional Internaldeadline

deadline?: number

Absolute time beyond which evaluation should not proceed

ReadonlyE

E: BoxedExpression

ReadonlyFalse

False: BoxedExpression

ReadonlyHalf

Half: BoxedExpression

ReadonlyI

I: BoxedExpression

Readonly ExperimentaliterationLimit

iterationLimit: number

latexDictionary

latexDictionary: readonly LatexDictionaryEntry[]

ReadonlyNaN

NaN: BoxedExpression

ReadonlyNegativeInfinity

NegativeInfinity: BoxedExpression

ReadonlyNegativeOne

NegativeOne: BoxedExpression

ReadonlyNothing

Nothing: BoxedExpression

ReadonlyNumbers

Numbers: BoxedDomain

numericMode

numericMode: NumericMode

The numeric evaluation mode:

Mode
"auto" Use bignum or complex numbers.
"machine" IEEE 754-2008, 64-bit floating point numbers: 52-bit mantissa, about 15 digits of precision
"bignum" Arbitrary precision floating point numbers, as provided by the "decimal.js" library
"complex" Complex number represented by two machine numbers, a real and an imaginary part, as provided by the "complex.js" library

ReadonlyOne

One: BoxedExpression

ReadonlyPi

Pi: BoxedExpression

ReadonlyPositiveInfinity

PositiveInfinity: BoxedExpression

Readonly ExperimentalrecursionLimit

recursionLimit: number

Readonlystats

stats: ComputeEngineStats

strict

strict: boolean

ReadonlyStrings

Strings: BoxedDomain

Readonly ExperimentaltimeLimit

timeLimit: number

tolerance

tolerance: number

ReadonlyTrue

True: BoxedExpression

ReadonlyVoid

Void: BoxedDomain

ReadonlyZero

Zero: BoxedExpression

Accessors

assumptions

  • get assumptions(): ExpressionMapInterface<boolean>

  • Returns ExpressionMapInterface<boolean>

jsonSerializationOptions

  • get jsonSerializationOptions(): Readonly<JsonSerializationOptions>

  • Returns Readonly<JsonSerializationOptions>

  • set jsonSerializationOptions(val): void

  • Parameters

    Returns void

latexOptions

precision

  • get precision(): number

  • Returns number

  • set precision(p): void

  • Parameters

    • p: number | "machine"

    Returns void

Methods

_fn

  • _fn(head, ops, metadata?): BoxedExpression
  • Internal

    This is a primitive to create a boxed function. It doesn't perform any checks or normalization on its arguments.

    In general, consider using ce.fn() or ce.box() instead.

    The result is canonical, but the caller has to ensure that all the conditions are met (i.e. ops properly normalized and sorted, all ops canonical, etc..) so that the result is actually canonical.

    Parameters

    Returns BoxedExpression

_register

  • _register(expr): void
  • Internal

    Parameters

    Returns void

_unregister

  • _unregister(expr): void
  • Internal

    Parameters

    Returns void

add

array

ask

assign

  • assign(ids): IComputeEngine

  • Parameters

    Returns IComputeEngine

  • assign(id, value): IComputeEngine

  • Parameters

    Returns IComputeEngine

  • assign(arg1, arg2?): IComputeEngine

  • Parameters

    Returns IComputeEngine

assume

  • assume(predicate): AssumeResult

  • Parameters

    Returns AssumeResult

box

cache

  • cache<T>(name, build, purge?): T
  • Internal

    Type Parameters

    • T

    Parameters

    • name: string
    • build: (() => T)
        • (): T

        • Returns T

    • Optionalpurge: ((T: any) => undefined | T)
        • (T): undefined | T

        • Parameters

          • T: any

          Returns undefined | T

    Returns T

canonical

checkContinueExecution

  • checkContinueExecution(): void
  • Internal

    Returns void

chop

  • chop(n): number

  • Parameters

    • n: number

    Returns number

  • chop(n): 0 | Decimal

  • Parameters

    Returns 0 | Decimal

  • chop(n): 0 | Complex

  • Parameters

    Returns 0 | Complex

  • chop(n): number | Decimal | Complex

  • Parameters

    Returns number | Decimal | Complex

declare

defineFunction

defineSymbol

div

domain

domainError

error

fn

  • fn(head, ops, options?): BoxedExpression

  • Create a boxed function expression.

    Parameters

    Returns BoxedExpression

forget

  • forget(symbol?): void

  • Parameters

    • Optionalsymbol: string | string[]

    Returns void

hold

inv

isBignum

  • isBignum(a): a is Decimal

  • Parameters

    • a: unknown

    Returns a is Decimal

isComplex

  • isComplex(a): a is Complex

  • Parameters

    • a: unknown

    Returns a is Complex

lookupFunction

lookupSymbol

  • lookupSymbol(name, wikidata?, scope?): undefined | BoxedSymbolDefinition

  • Parameters

    • name: string
    • Optionalwikidata: string
    • Optionalscope: RuntimeScope

    Returns undefined | BoxedSymbolDefinition

mul

neg

number

  • number(value, options?): BoxedExpression

  • Parameters

    • value:
          | string
          | number
          | bigint
          | Decimal
          | Complex
          | MathJsonNumber
          | Rational
    • Optionaloptions: {
          canonical?: boolean;
          metadata?: Metadata;
      }
      • Optionalcanonical?: boolean
      • Optionalmetadata?: Metadata

    Returns BoxedExpression

pair

parse

  • parse(s, options?): BoxedExpression

  • Parameters

    Returns BoxedExpression

  • parse(s, options?): null

  • Parameters

    Returns null

  • parse(s, options?): null | BoxedExpression

  • Parameters

    Returns null | BoxedExpression

pattern

  • pattern(expr): Pattern

  • Parameters

    Returns Pattern

popScope

  • popScope(): IComputeEngine

  • Returns IComputeEngine

pow

pushScope

  • pushScope(scope?): IComputeEngine

  • Parameters

    Returns IComputeEngine

reset

  • reset(): void
  • Internal

    Returns void

resetContext

  • resetContext(): void

  • Returns void

rules

  • rules(rules): BoxedRuleSet

  • Parameters

    Returns BoxedRuleSet

serialize

  • serialize(expr, options?): string

  • Parameters

    • expr: SemiBoxedExpression
    • Optionaloptions: {
          canonical?: boolean;
      }
      • Optionalcanonical?: boolean

    Returns string

shouldContinueExecution

  • shouldContinueExecution(): boolean
  • Internal

    Returns boolean

sqrt

string

  • string(s, metadata?): BoxedExpression

  • Parameters

    Returns BoxedExpression

swapScope

  • swapScope(scope): null | RuntimeScope

  • Parameters

    Returns null | RuntimeScope

symbol

  • symbol(sym, options?): BoxedExpression

  • Parameters

    • sym: string
    • Optionaloptions: {
          canonical?: boolean;
          metadata?: Metadata;
      }
      • Optionalcanonical?: boolean
      • Optionalmetadata?: Metadata

    Returns BoxedExpression

tuple

  • tuple(elements, metadata?): BoxedExpression

  • Parameters

    • elements: number[]
    • Optionalmetadata: Metadata

    Returns BoxedExpression

  • tuple(elements, metadata?): BoxedExpression

  • Parameters

    Returns BoxedExpression

verify

  • verify(query): boolean

  • Parameters

    Returns boolean

Settings

Member Visibility

On This Page

Properties
Accessors
Methods