@cortex-js/compute-engine 0.28.0 → 0.29.1

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

@@ -1,10 +1,9 @@
-/* 0.28.0 */
-import type { BoxedExpression, CollectionHandlers, CompiledExpression, EvaluateOptions, Sign } from './public';
-import { Type, TypeString } from '../../common/type/types';
+/* 0.29.1 */
 import { OneOf } from '../../common/one-of';
 import { BoxedType } from '../../common/type/boxed-type';
+import type { FunctionDefinition, BoxedExpression, BoxedFunctionDefinition, CollectionHandlers, CompiledExpression, EvaluateOptions, ComputeEngine, RuntimeScope, Sign } from '../global-types';
 export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition {
-    engine: IComputeEngine;
+    engine: ComputeEngine;
     scope: RuntimeScope;
     name: string;
     description?: string | string[];
@@ -21,34 +20,34 @@ export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition
     signature: BoxedType;
     inferredSignature: boolean;
     type?: (ops: ReadonlyArray<BoxedExpression>, options: {
-        engine: IComputeEngine;
+        engine: ComputeEngine;
     }) => BoxedType | Type | TypeString | undefined;
     sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
-        engine: IComputeEngine;
+        engine: ComputeEngine;
     }) => Sign | undefined;
     eq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
     neq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
     even?: (ops: ReadonlyArray<BoxedExpression>, options: {
-        engine: IComputeEngine;
+        engine: ComputeEngine;
     }) => boolean | undefined;
     canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
-        engine: IComputeEngine;
+        engine: ComputeEngine;
     }) => BoxedExpression | null;
     evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: Partial<EvaluateOptions> & {
-        engine: IComputeEngine;
+        engine: ComputeEngine;
     }) => BoxedExpression | undefined;
     evaluateAsync?: (ops: ReadonlyArray<BoxedExpression>, options?: Partial<EvaluateOptions> & {
-        engine?: IComputeEngine;
+        engine?: ComputeEngine;
     }) => Promise<BoxedExpression | undefined>;
     evalDimension?: (ops: ReadonlyArray<BoxedExpression>, options: {
-        engine: IComputeEngine;
+        engine: ComputeEngine;
     }) => BoxedExpression;
     compile?: (expr: BoxedExpression) => CompiledExpression;
     collection?: Partial<CollectionHandlers>;
-    constructor(ce: IComputeEngine, name: string, def: FunctionDefinition);
+    constructor(ce: ComputeEngine, name: string, def: FunctionDefinition);
     infer(sig: Type): void;
     update(def: FunctionDefinition): void;
     reset(): void;
 }
-export declare function makeFunctionDefinition(engine: IComputeEngine, name: string, def: OneOf<[FunctionDefinition | BoxedFunctionDefinition]>): BoxedFunctionDefinition;
+export declare function makeFunctionDefinition(engine: ComputeEngine, name: string, def: OneOf<[FunctionDefinition | BoxedFunctionDefinition]>): BoxedFunctionDefinition;
 export declare function isBoxedFunctionDefinition(x: any): x is BoxedFunctionDefinition;

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

@@ -1,7 +1,6 @@
-/* 0.28.0 */
-import type { BoxedFunctionDefinition, IComputeEngine, BoxedRuleSet, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, RuntimeScope, BoxedSubstitution, EvaluateOptions, BoxedBaseDefinition, Rule, CanonicalOptions } from '../public';
-import type { BoxedExpression, Sign } from './public';
-import { NumericValue } from '../numeric-value/public';
+/* 0.29.1 */
+import type { SimplifyOptions, ReplaceOptions, PatternMatchOptions, BoxedExpression, BoxedBaseDefinition, BoxedFunctionDefinition, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, ComputeEngine, Metadata, Rule, RuntimeScope, Sign, Substitution } from '../global-types';
+import { NumericValue } from '../numeric-value/types';
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { Type } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
@@ -16,8 +15,6 @@ import { BoxedType } from '../../common/type/boxed-type';
  * The definition contains the signature of the function, and the
  * implementation of the function.
  *
- * @noInheritDoc
- *
  */
 export declare class BoxedFunction extends _BoxedExpression {
     private readonly _name;
@@ -32,7 +29,7 @@ export declare class BoxedFunction extends _BoxedExpression {
     private _valueN;
     private _sgn;
     private _type;
-    constructor(ce: IComputeEngine, name: string, ops: ReadonlyArray<BoxedExpression>, options?: {
+    constructor(ce: ComputeEngine, name: string, ops: ReadonlyArray<BoxedExpression>, options?: {
         metadata?: Metadata;
         canonical?: boolean;
         structural?: boolean;

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

@@ -1,16 +1,14 @@
-/* 0.28.0 */
+/* 0.29.1 */
 import { Decimal } from 'decimal.js';
-import type { BoxedExpression, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution, EvaluateOptions, BoxedRuleSet, ReplaceOptions, Rule, Substitution, CanonicalOptions, SimplifyOptions, Sign } from '../public';
 import type { Expression, MathJsonNumber } from '../../math-json';
-import { SmallInteger } from '../numerics/numeric';
-import { Rational } from '../numerics/rationals';
-import { ExactNumericValueData, NumericValue, NumericValueData } from '../numeric-value/public';
+import type { Rational, SmallInteger } from '../numerics/types';
+import { ExactNumericValueData, NumericValue, NumericValueData } from '../numeric-value/types';
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
+import type { BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, ComputeEngine, Metadata, Rule, Sign, Substitution, BoxedExpression, PatternMatchOptions, ReplaceOptions, SimplifyOptions } from '../global-types';
 /**
  * BoxedNumber
  *
- * @noInheritDoc
  */
 export declare class BoxedNumber extends _BoxedExpression {
     protected readonly _value: SmallInteger | NumericValue;
@@ -27,7 +25,7 @@ export declare class BoxedNumber extends _BoxedExpression {
      * We may store as a machine number if a Decimal is passed that is in machine
      * range
      */
-    constructor(ce: IComputeEngine, value: SmallInteger | NumericValueData | ExactNumericValueData | NumericValue, options?: {
+    constructor(ce: ComputeEngine, value: SmallInteger | NumericValueData | ExactNumericValueData | NumericValue, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     });
@@ -90,4 +88,4 @@ export declare class BoxedNumber extends _BoxedExpression {
     evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
     N(): BoxedExpression;
 }
-export declare function canonicalNumber(ce: IComputeEngine, value: number | bigint | string | Decimal | Complex | Rational | NumericValue | MathJsonNumber): number | NumericValue;
+export declare function canonicalNumber(ce: ComputeEngine, value: number | bigint | string | Decimal | Complex | Rational | NumericValue | MathJsonNumber): number | NumericValue;

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
-import type { BoxedExpression } from './public';
+/* 0.29.1 */
+import type { BoxedExpression } from '../global-types';
 export declare function isWildcard(expr: BoxedExpression): expr is BoxedSymbol;
 export declare function wildcardName(expr: BoxedExpression): string | null;

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

@@ -1,14 +1,13 @@
-/* 0.28.0 */
+/* 0.29.1 */
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
 /**
  * BoxedString
  *
- * @noInheritDoc
  */
 export declare class BoxedString extends _BoxedExpression {
     private readonly _string;
-    constructor(ce: IComputeEngine, expr: string, metadata?: Metadata);
+    constructor(ce: ComputeEngine, expr: string, metadata?: Metadata);
     get json(): string;
     get hash(): number;
     get operator(): string;

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.1 */
 import { Type, TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
 /**
@@ -44,7 +44,7 @@ export declare class _BoxedSymbolDefinition implements BoxedSymbolDefinition {
     neq?: (a: BoxedExpression) => boolean | undefined;
     cmp?: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
     collection?: Partial<CollectionHandlers>;
-    constructor(ce: IComputeEngine, name: string, def: SymbolDefinition);
+    constructor(ce: ComputeEngine, name: string, def: SymbolDefinition);
     get isFunction(): boolean;
     get isConstant(): boolean;
     /** The symbol was previously inferred, but now it has a declaration. Update the def accordingly (we can't replace defs, as other expressions may be referencing them) */

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

@@ -1,10 +1,10 @@
-/* 0.28.0 */
+/* 0.29.1 */
 import type { Expression } from '../../math-json/types';
 import type { Type, TypeString } from '../../common/type/types';
-import type { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, BoxedSubstitution, Rule, CanonicalOptions, BoxedRule, Sign } from './public';
-import { NumericValue } from '../numeric-value/public';
+import type { BoxedExpression, SimplifyOptions, PatternMatchOptions, ReplaceOptions, RuntimeScope, BoxedSymbolDefinition, BoxedFunctionDefinition, ComputeEngine, Metadata, CanonicalOptions, BoxedBaseDefinition, BoxedSubstitution, EvaluateOptions, Rule, BoxedRule, BoxedRuleSet, Substitution, Sign } from '../global-types';
+import { NumericValue } from '../numeric-value/types';
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { BigNum } from '../numerics/bignum';
+import type { BigNum } from '../numerics/types';
 import type { OneOf } from '../../common/one-of';
 import { BoxedType } from '../../common/type/boxed-type';
 /**
@@ -20,7 +20,6 @@ import { BoxedType } from '../../common/type/boxed-type';
  * not a function expression, i.e. `Sin`, not `["Sin", "Pi"]`. This is used
  * for example in `["InverseFunction", "Sin"]`
  *
- * @noInheritDoc
  *
  */
 export declare class BoxedSymbol extends _BoxedExpression {
@@ -29,7 +28,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
     private _hash;
     private _def;
     private _isStructural;
-    constructor(ce: IComputeEngine, name: string, options?: {
+    constructor(ce: ComputeEngine, name: string, options?: {
         metadata?: Metadata;
         canonical?: CanonicalOptions;
         structural?: boolean;
@@ -129,4 +128,4 @@ export declare class BoxedSymbol extends _BoxedExpression {
     indexOf(expr: BoxedExpression): number;
     subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
 }
-export declare function makeCanonicalSymbol(ce: IComputeEngine, name: string): BoxedExpression;
+export declare function makeCanonicalSymbol(ce: ComputeEngine, name: string): BoxedExpression;

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

@@ -1,10 +1,9 @@
-/* 0.28.0 */
-import type { BoxedExpression, IComputeEngine, EvaluateOptions, SimplifyOptions, Metadata, BoxedSubstitution, PatternMatchOptions, BoxedBaseDefinition, BoxedFunctionDefinition } from '../public';
-import { TensorDataType } from './tensor-fields';
-import { NumericValue } from '../numeric-value/public';
+/* 0.29.1 */
+import { NumericValue } from '../numeric-value/types';
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { AbstractTensor, TensorData } from '../tensor/tensors';
+import { AbstractTensor } from '../tensor/tensors';
 import { BoxedType } from '../../common/type/boxed-type';
+import type { ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, BoxedFunctionDefinition, BoxedSubstitution, EvaluateOptions, TensorData, BoxedExpression, SimplifyOptions, PatternMatchOptions } from '../global-types';
 /**
  * A boxed tensor represents an expression that can be represented by a tensor.
  * This could be a vector, matrix or multi-dimensional array.
@@ -15,8 +14,6 @@ import { BoxedType } from '../../common/type/boxed-type';
  * The structural counterpart (expression if input is tensor, or tensor
  * if input is expression) is created lazily.
  *
- * @noInheritDoc
- *
  */
 export declare class BoxedTensor extends _BoxedExpression {
     readonly options?: {
@@ -27,7 +24,7 @@ export declare class BoxedTensor extends _BoxedExpression {
     private readonly _operator?;
     private readonly _ops?;
     private _expression;
-    constructor(ce: IComputeEngine, input: {
+    constructor(ce: ComputeEngine, input: {
         op?: string;
         ops: ReadonlyArray<BoxedExpression>;
     } | AbstractTensor<'expression'>, options?: {

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.1 */
     value: T | null;
     generation: number | undefined;
 };

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

@@ -1,2 +1,2 @@
-/* 0.28.0 */
+/* 0.29.1 */
 export declare function canonicalForm(expr: BoxedExpression, forms: CanonicalOptions): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.1 */
 /**
  * Structural equality of boxed expressions.
  */

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

@@ -1,8 +1,8 @@
-/* 0.28.0 */
-export declare function expandProducts(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
+/* 0.29.1 */
+export declare function expandProducts(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
 export declare function choose(n: number, k: number): number;
 /** Attempt to transform the expression (h, ops) into a sum */
-export declare function expandFunction(ce: IComputeEngine, h: string, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
+export declare function expandFunction(ce: ComputeEngine, h: string, ops: ReadonlyArray<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.

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.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,5 +1,4 @@
-/* 0.28.0 */
-import { NumericValue } from '../numeric-value/public';
+/* 0.29.1 */
 /** Combine rational expressions into a single fraction */
 export declare function together(op: BoxedExpression): BoxedExpression;
 /**
@@ -9,4 +8,3 @@ export declare function together(op: BoxedExpression): BoxedExpression;
  * - (2x) * (2y) -> 4xy
  */
 export declare function factor(expr: BoxedExpression): BoxedExpression;
-export declare function getPiTerm(expr: BoxedExpression): [k: NumericValue, t: NumericValue];

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

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

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.1 */
 /** Apply the function `f` to each operand of the expression `expr`,
  * account for the 'lazy' property of the function definition:
  *

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.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.28.0 */
+/* 0.29.1 */
 export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
@@ -8,4 +8,4 @@ export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
  * `-3x` -> ["Negate, ["Multiply", 3, "x"]] -> ["Multiply, -3, x]
  */
 export declare function negate(expr: BoxedExpression): BoxedExpression;
-export declare function negateProduct(ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>): BoxedExpression;
+export declare function negateProduct(ce: ComputeEngine, args: ReadonlyArray<BoxedExpression>): BoxedExpression;

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

@@ -1,6 +1,6 @@
-/* 0.28.0 */
-import type { Rational } from '../numerics/rationals';
-import type { BoxedExpression } from './public';
+/* 0.29.1 */
+import type { Rational } from '../numerics/types';
+import type { BoxedExpression } from '../global-types';
 export declare function asRational(expr: BoxedExpression): Rational | undefined;
 export declare function asBigint(expr: BoxedExpression | undefined): bigint | null;
 export declare function asBignum(expr: BoxedExpression | undefined): Decimal | null;

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

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

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

@@ -1,6 +1,6 @@
-/* 0.28.0 */
-import { Rational } from '../numerics/rationals';
-import { NumericValue } from '../numeric-value/public';
+/* 0.29.1 */
+import { NumericValue } from '../numeric-value/types';
+import type { BoxedExpression, ComputeEngine } from '../global-types';
 /**
  * Group terms in a product by common term.
  *
@@ -21,7 +21,7 @@ export declare class Product {
     readonly options?: {
         canonical?: boolean;
     };
-    engine: IComputeEngine;
+    engine: ComputeEngine;
     coefficient: NumericValue;
     terms: {
         term: BoxedExpression;
@@ -29,7 +29,7 @@ export declare class Product {
     }[];
     private _isCanonical;
     static from(expr: BoxedExpression): Product;
-    constructor(ce: IComputeEngine, xs?: ReadonlyArray<BoxedExpression>, options?: {
+    constructor(ce: ComputeEngine, xs?: ReadonlyArray<BoxedExpression>, options?: {
         canonical?: boolean;
     });
     /**

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.1 */
 export declare const ConditionParent: {
     boolean: string;
     string: string;
@@ -100,7 +100,7 @@ export declare function checkConditions(x: BoxedExpression, conditions: string[]
 /**
  * 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?: {
+export declare function boxRules(ce: ComputeEngine, rs: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
     canonical?: boolean;
 }): BoxedRuleSet;
 /**

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

@@ -1,3 +1,3 @@
-/* 0.28.0 */
-import type { BoxedExpression, IComputeEngine, JsonSerializationOptions } from '../public';
-export declare function serializeJson(ce: IComputeEngine, expr: BoxedExpression, options: Readonly<JsonSerializationOptions>): Expression;
+/* 0.29.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,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.1 */
 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;

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.1 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };

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

@@ -1,5 +1,4 @@
-/* 0.28.0 */
-import { Rule } from '../public';
+/* 0.29.1 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality

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

@@ -1,8 +1,8 @@
-/* 0.28.0 */
+/* 0.29.1 */
 export declare class Terms {
     private engine;
     private terms;
-    constructor(ce: IComputeEngine, terms: ReadonlyArray<BoxedExpression>);
+    constructor(ce: ComputeEngine, terms: ReadonlyArray<BoxedExpression>);
     private add;
     private find;
     N(): BoxedExpression;

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

@@ -1,16 +1,9 @@
-/* 0.28.0 */
+/* 0.29.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;
 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 processInverseFunction(ce: ComputeEngine, 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;
-/**
- * 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;

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

@@ -1,11 +1,12 @@
-/* 0.28.0 */
+/* 0.29.1 */
 import { Type } from '../../common/type/types';
+import { NumericValue } from '../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;
+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;
@@ -40,6 +41,14 @@ export declare function getImaginaryFactor(expr: number | BoxedExpression): Boxe
 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 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.
+ *
+ * @param x
+ * @returns
+ */
+export declare function canonicalAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
+export declare function getPiTerm(expr: BoxedExpression): [k: NumericValue, t: NumericValue];

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

@@ -1,12 +1,11 @@
-/* 0.28.0 */
-import type { IComputeEngine } from '../public';
-import { Type } from '../../common/type/types';
+/* 0.29.1 */
+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: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, count: number): ReadonlyArray<BoxedExpression>;
+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
@@ -23,7 +22,7 @@ export declare function checkArity(ce: IComputeEngine, ops: ReadonlyArray<BoxedE
  *
  * Flattens sequence expressions.
  */
-export declare function checkNumericArgs(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, options?: number | {
+export declare function checkNumericArgs(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, options?: number | {
     count?: number;
     flatten?: string;
 }): ReadonlyArray<BoxedExpression>;
@@ -32,12 +31,12 @@ export declare function checkNumericArgs(ce: IComputeEngine, ops: ReadonlyArray<
  *
  * Converts the arguments to canonical
  */
-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>;
+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: IComputeEngine, arg: BoxedExpression | BoxedExpression | undefined | null): BoxedExpression;
+export declare function checkPure(ce: ComputeEngine, arg: BoxedExpression | BoxedExpression | undefined | null): BoxedExpression;
 /**
  *
  * If the arguments match the parameters, return null.
@@ -46,4 +45,4 @@ export declare function checkPure(ce: IComputeEngine, arg: BoxedExpression | Box
  * arguments.
  *
  */
-export declare function validateArguments(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, signature: Type, lazy?: boolean, threadable?: boolean): ReadonlyArray<BoxedExpression> | null;
+export declare function validateArguments(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, signature: Type, lazy?: boolean, threadable?: boolean): ReadonlyArray<BoxedExpression> | null;

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.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

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

@@ -1,7 +1,5 @@
-/* 0.28.0 */
-import type { BoxedExpression } from './public';
-export type CompiledType = boolean | number | string | object;
-export type JSSource = string;
+/* 0.29.1 */
+import { BoxedExpression, CompiledType, JSSource } from './global-types';
 export type CompiledOperators = Record<MathJsonIdentifier, [
     op: string,
     prec: number

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

@@ -1,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.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,4 +1,4 @@
-/* 0.28.0 */
+/* 0.29.1 */
 /***
  * ### THEORY OF OPERATIONS
  *