@cortex-js/compute-engine 0.16.0 → 0.18.0

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

@@ -1,3 +1,3 @@
-/* 0.16.0 */
-export type CanonicalArithmeticFunctions = 'Add' | 'Negate' | 'Multiply' | 'Divide' | 'Power' | 'Ln';
+/* 0.18.0 */
+export type CanonicalArithmeticFunctions = 'Add' | 'Negate' | 'Sqrt' | 'Multiply' | 'Divide' | 'Power' | 'Ln';
 export declare const ARITHMETIC_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const CALCULUS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const COLLECTIONS_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const COMPLEX_LIBRARY: IdentifierDefinitions[];

package/dist/types/compute-engine/library/control-structures.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const CONTROL_STRUCTURES_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const CORE_LIBRARY: IdentifierDefinitions[];

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

@@ -1,6 +1,7 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DOMAIN_CONSTRUCTORS: string[];
 export declare const DOMAIN_ALIAS: {
+    Functions: (string | string[])[];
     NumericFunctions: (string | string[])[];
     RealFunctions: (string | string[])[];
     LogicOperators: (string | string[])[];
@@ -11,5 +12,5 @@ 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: string): string[];
+export declare function ancestors(dom: DomainLiteral): DomainLiteral[];
 export declare function domainSetsLibrary(): IdentifierDefinitions;

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

@@ -1,5 +1,5 @@
-/* 0.16.0 */
-import { IComputeEngine, IdentifierDefinitions } from '../public';
+/* 0.18.0 */
+import { FunctionDefinition, IComputeEngine, IdentifierDefinitions, SymbolDefinition } from '../public';
 export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
 export declare const LIBRARIES: {
     [category in LibraryCategory]?: IdentifierDefinitions | IdentifierDefinitions[];
@@ -15,3 +15,5 @@ export declare const LIBRARIES: {
  *
  */
 export declare function setIdentifierDefinitions(engine: IComputeEngine, table: IdentifierDefinitions): void;
+export declare function isSymbolDefinition(def: any): def is SymbolDefinition;
+export declare function isFunctionDefinition(def: any): def is FunctionDefinition;

package/dist/types/compute-engine/library/linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const LINEAR_ALGEBRA_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const LOGIC_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const POLYNOMIALS_LIBRARY: IdentifierDefinitions[];

package/dist/types/compute-engine/library/random-expression.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare function randomExpression(level?: number): Expression;

package/dist/types/compute-engine/library/relational-operator.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const RELOP_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const SETS_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const STATISTICS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const TRIGONOMETRY_LIBRARY: IdentifierDefinitions[];

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

@@ -1,4 +1,2 @@
-/* 0.16.0 */
-export declare function isSymbolDefinition(def: any): def is SymbolDefinition;
-export declare function isFunctionDefinition(def: any): def is FunctionDefinition;
+/* 0.18.0 */
 export declare function normalizeLimits(range: BoxedExpression): [index: string, lower: number, upper: number, isFinite: boolean];

package/dist/types/compute-engine/numerics/numeric-bigint.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare function bigint(a: Decimal | number | bigint | string): bigint;
 export declare function gcd(a: bigint, b: bigint): bigint;
 export declare function lcm(a: bigint, b: bigint): bigint;

package/dist/types/compute-engine/numerics/numeric-bignum.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 import { IComputeEngine } from '../public';
 export declare function gcd(a: Decimal, b: Decimal): Decimal;
 export declare function lcm(a: Decimal, b: Decimal): Decimal;

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,3 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function gammaln(c: Complex): Complex;

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

@@ -1,5 +1,5 @@
-/* 0.16.0 */
-import Decimal from 'decimal.js';
+/* 0.18.0 */
+import { Decimal } from 'decimal.js';
 import { BoxedExpression } from '../public';
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
@@ -98,3 +98,11 @@ export declare function centeredDiff8thOrder(f: (number: any) => number, x: numb
  *
  */
 export declare function monteCarloEstimate(f: (x: number) => number, a: number, b: number, n?: number): number;
+/**
+ *
+ * @param f
+ * @param x
+ * @param dir Direction of approach: > 0 for right, < 0 for left, 0 for both
+ * @returns
+ */
+export declare function limit(f: (x: number) => number, x: number, dir?: number): number;

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare function isPrime(n: number): boolean | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare function isRational(x: any | null): x is Rational;
 export declare function isMachineRational(x: any | null): x is [number, number];
 export declare function isBigRational(x: any | null): x is [bigint, bigint];

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

@@ -0,0 +1,80 @@
+/* 0.18.0 */
+
+    Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
+
+
+    The `Richardson` module provides a function `extrapolate` that
+    extrapolates a given function `f(x)` to `f(x0)`, evaluating
+    `f` only  at a geometric sequence of points `> x0`
+    (or optionally `< x0`).
+    
+    The key algorithm is Richardson extrapolation using a Neville—Aitken
+    tableau, which adaptively increases the degree of an extrapolation
+    polynomial until convergence is achieved to a desired tolerance
+    (or convergence stalls due to e.g. floating-point errors).  This
+    allows one to obtain `f(x0)` to high-order accuracy, assuming
+    that `f(x0+h)` has a Taylor series or some other power
+    series in `h`.
+*/
+export interface ExtrapolateOptions {
+    contract?: number;
+    step?: number;
+    power?: number;
+    atol?: number;
+    rtol?: number;
+    maxeval?: number;
+    breaktol?: number;
+}
+/**
+ *
+ * Extrapolate `f(x)` to `f₀ ≈ f(x0)`, evaluating `f` only at `x > x0` points
+(or `x < x0` if `h < 0`) using Richardson extrapolation starting at
+`x=x₀+h`.  It returns a tuple `(f₀, err)` of the estimated `f(x0)`
+and an error estimate.
+
+The return value of `f` can be any type supporting `±` and `norm`
+operations (i.e. a normed vector space).
+Similarly, `h` and `x0` can be in any normed vector space,
+in which case `extrapolate` performs Richardson extrapolation
+of `f(x0+s*h)` to `s=0⁺` (i.e. it takes the limit as `x` goes
+to `x0` along the `h` direction).
+
+On each step of Richardson extrapolation, it shrinks `x-x0` by
+a factor of `contract`, stopping when the estimated error is
+`< max(rtol*norm(f₀), atol)`, when the estimated error
+increases by more than `breaktol` (e.g. due to numerical errors in the
+computation of `f`), when `f` returns a non-finite value (`NaN` or `Inf`),
+ or when `f` has been evaluated `maxeval` times.   Note that
+if the function may converge to zero, you may want
+specify a nonzero `atol` (which cannot be set by default
+because it depends on the scale/units of `f`); alternatively,
+in such cases `extrapolate` will halt when it becomes
+limited by the floating-point precision.   (Passing `breaktol=Inf`
+can be useful to force `extrapolate` to continue shrinking `h` even
+if polynomial extrapolation is initially failing to converge,
+possibly at the cost of extraneous function evaluations.)
+
+
+If `x0 = ±∞` (`±Inf`), then `extrapolate` computes the limit of
+`f(x)` as `x ⟶ ±∞` using geometrically *increasing* values
+of `h` (by factors of `1/contract`).
+
+In general, the starting `h` should be large enough that `f(x0+h)`
+can be computed accurately and efficiently (e.g. without
+severe cancellation errors), but small enough that `f` does not
+oscillate much between `x0` and `h`.  i.e. `h` should be a typical
+scale over which the function `f` varies significantly.
+
+Technically, Richardson extrapolation assumes that `f(x0+h)` can
+be expanded in a power series in `h^power`, where the default
+`power=1` corresponds to an ordinary Taylor series (i.e. assuming
+`f` is analytic at `x0`).  If this is not true, you may obtain
+slow convergence from `extrapolate`, but you can pass a different
+value of `power` (e.g. `power=0.5`) if your `f` has some different
+(Puiseux) power-series expansion.   Conversely, if `f` is
+an *even* function around `x0`, i.e. `f(x0+h) == f(x0-h)`,
+so that its Taylor series contains only *even* powers of `h`,
+you can accelerate convergence by passing `power=2`.
+
+ */
+export declare function extrapolate(f: (x: number) => number, x0: number, options?: ExtrapolateOptions): [val: number, err: number];