@cortex-js/compute-engine 0.12.5 → 0.12.7

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -10,7 +10,7 @@
 import type { Decimal } from 'decimal.js';
 import type { Complex } from 'complex.js';
 import type { Expression, MathJsonDictionary, MathJsonFunction, MathJsonNumber, MathJsonString, MathJsonSymbol } from '../math-json/math-json-format';
-import type { NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
+import type { LatexDictionaryEntry, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
 export * from './latex-syntax/public';
 export type Rational = [number, number] | [bigint, bigint];
 /**
@@ -1521,6 +1521,7 @@ export interface ComputeEngineStats {
 }
 /** @internal */
 export interface IComputeEngine {
+    latexDictionary: readonly LatexDictionaryEntry[];
     /** @internal */
     readonly _ZERO: BoxedExpression;
     /** @internal */
@@ -1573,10 +1574,105 @@ export interface IComputeEngine {
     chop(n: Decimal): Decimal | 0;
     chop(n: Complex): Complex | 0;
     chop(n: number | Decimal | Complex): number | Decimal | Complex;
-    /** @internal */
+    /** Create an arbitrary precision number.
+     *
+     * The return value is an object with methods to perform arithmetic
+     * operations:
+     * - `toNumber()`: convert to a JavaScript `number` with potential loss of precision
+     * - `add()`
+     * - `sub()`
+     * - `neg()` (unary minus)
+     * - `mul()`
+     * - `div()`
+     * - `pow()`
+     * - `sqrt()` (square root)
+     * - `cbrt()` (cube root)
+     * - `exp()`  (e^x)
+     * - `log()`
+     * - `ln()` (natural logarithm)
+     * - `mod()`
+  
+     * - `abs()`
+     * - `ceil()`
+     * - `floor()`
+     * - `round()`
+  
+     * - `equals()`
+     * - `gt()`
+     * - `gte()`
+     * - `lt()`
+     * - `lte()`
+     *
+     * - `cos()`
+     * - `sin()`
+     * - `tanh()`
+     * - `acos()`
+     * - `asin()`
+     * - `atan()`
+     * - `cosh()`
+     * - `sinh()`
+     * - `acosh()`
+     * - `asinh()`
+     * - `atanh()`
+     *
+     * - `isFinite()`
+     * - `isInteger()`
+     * - `isNaN()`
+     * - `isNegative()`
+     * - `isPositive()`
+     * - `isZero()`
+     * - `sign()` (1, 0 or -1)
+     *
+     */
     bignum: (a: Decimal.Value | bigint) => Decimal;
-    /** @internal */
+    /** Create a complex number.
+     * The return value is an object with methods to perform arithmetic
+     * operations:
+     * - `re` (real part, as a JavaScript `number`)
+     * - `im` (imaginary part, as a JavaScript `number`)
+     * - `add()`
+     * - `sub()`
+     * - `neg()` (unary minus)
+     * - `mul()`
+     * - `div()`
+     * - `pow()`
+     * - `sqrt()` (square root)
+     * - `exp()`  (e^x)
+     * - `log()`
+     * - `ln()` (natural logarithm)
+     * - `mod()`
+  
+     * - `abs()`
+     * - `ceil()`
+     * - `floor()`
+     * - `round()`
+  
+     * - `arg()` the angle of the complex number
+     * - `inverse()` the inverse of the complex number 1/z
+     * - `conjugate()` the conjugate of the complex number
+  
+     * - `equals()`
+     *
+     * - `cos()`
+     * - `sin()`
+     * - `tanh()`
+     * - `acos()`
+     * - `asin()`
+     * - `atan()`
+     * - `cosh()`
+     * - `sinh()`
+     * - `acosh()`
+     * - `asinh()`
+     * - `atanh()`
+     *
+     * - `isFinite()`
+     * - `isNaN()`
+     * - `isZero()`
+     * - `sign()` (1, 0 or -1)
+     */
     complex: (a: number | Complex, b?: number) => Complex;
+    isBignum(a: unknown): a is Decimal;
+    isComplex(a: unknown): a is Complex;
     set precision(p: number | 'machine');
     get precision(): number;
     costFunction: (expr: BoxedExpression) => number;

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 /**
  * Go through all the rules in the rule set, and for all the rules that match
  * return the rhs of the rule applied to `expr`.

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 export declare function distribute(expr: 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.

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 /**
  * Flatten the arguments.
  * If `expr` was canonical, the result it canonical.

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
  * addition or multiplication or another `Negate`.

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 /**
  * Group terms in a product by common term.
  *

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 export declare class Sum {
     private engine;
     private _isCanonical;

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 import Decimal from 'decimal.js';
 import { BoxedExpression, Rational } from '../public';
 /**

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

@@ -1,3 +1,3 @@
-/* 0.12.5 */
-export declare const version = "0.12.5";
+/* 0.12.7 */
+export declare const version = "0.12.7";
 export { ComputeEngine } from './compute-engine/compute-engine';

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
     /** A human readable string to annotate this expression, since JSON does not
      * allow comments in its encoding */
     comment?: string;

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

@@ -1,4 +1,4 @@
-/* 0.12.5 */
+/* 0.12.7 */
 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;
@@ -69,6 +69,7 @@ export declare function mapArgs<T>(expr: Expression, fn: (x: Expression) => T):
  *
  */
 export declare function applyAssociativeOperator(op: string, lhs: Expression, rhs: Expression, associativity?: 'right' | 'left' | 'non' | 'both'): 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;

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

@@ -1,3 +1,3 @@
-/* 0.12.5 */
+/* 0.12.7 */
 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.12.5";
+export declare const version = "0.12.7";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.12.5",
+  "version": "0.12.7",
   "scripts": {
     "build": "bash ./scripts/build.sh",
     "clean": "bash ./scripts/clean.sh",