@cortex-js/compute-engine 0.15.0 → 0.16.0

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.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,9 +1,10 @@
-/* 0.15.0 */
+/* 0.16.0 */
 import { IComputeEngine } from '../public';
 export declare function gcd(a: Decimal, b: Decimal): Decimal;
 export declare function lcm(a: Decimal, b: Decimal): Decimal;
 export declare function factorial(ce: IComputeEngine, n: Decimal): Decimal;
-export declare function lngamma(ce: IComputeEngine, z: Decimal): Decimal;
+export declare function factorial2(ce: IComputeEngine, n: Decimal): Decimal;
+export declare function gammaln(ce: IComputeEngine, z: Decimal): Decimal;
 export declare function gamma(ce: IComputeEngine, z: Decimal): Decimal;
 /**
  * If the exponent of the bignum is in the range of the exponents

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

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

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.0 */
 import Decimal from 'decimal.js';
 import { BoxedExpression } from '../public';
 export declare const MACHINE_PRECISION_BITS = 53;
@@ -30,7 +30,8 @@ export declare function factorPower(n: number, exponent: number): [factor: numbe
 export declare function gcd(a: number, b: number): number;
 export declare function lcm(a: number, b: number): number;
 export declare function factorial(n: number): number;
-export declare function lngamma(z: number): number;
+export declare function factorial2(n: number): number;
+export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;
 export declare function fromDigits(s: string, base?: number): [value: number, rest: string];
 export declare function asFloat(expr: BoxedExpression): number | null;
@@ -39,4 +40,61 @@ export declare function asSmallInteger(expr: BoxedExpression): number | null;
 export declare function chop(n: number, tolerance: number): number;
 export declare function chop(n: Decimal, tolerance: number): 0 | Decimal;
 export declare function chop(n: Complex, tolerance: number): 0 | Complex;
+/**
+ * An approximation of the gaussian error function, Erf(), using
+ * Abramowitz and Stegun approximation.
+ *
+ * Thoughts for future improvements:
+ * - https://math.stackexchange.com/questions/321569/approximating-the-error-function-erf-by-analytical-functions
+ * - https://en.wikipedia.org/wiki/Error_function#Approximation_with_elementary_functions
+
+ *
+ * References:
+ * - NIST: https://dlmf.nist.gov/7.24#i
+ */
 export declare function erf(x: number): number;
+/**
+ * Trivial function, used when compiling.
+ */
+export declare function erfc(x: number): number;
+/**
+ * Inverse Error Function.
+ *
+ */
+export declare function erfInv(x: number): number;
+/**
+ * An 8th-order centered difference approximation can be used to get a highly
+ * accurate approximation of the first derivative of a function.
+ * The formula for the 8th-order centered difference approximation for the
+ * first derivative is given by:
+ *
+ * \[
+ * f'(x) \approx \frac{-f(x-4h) + 9f(x-3h) - 45f(x-2h) + 186f(x-h) - 186f(x+h) + 45f(x+2h) - 9f(x+3h) + f(x+4h)}{60h}
+ * \]
+ *
+ * Note: Mathematica uses an 8th order approximation for the first derivative
+ *
+ * f: the function
+ * x: the point at which to approximate the derivative
+ * h: the step size
+ */
+export declare function centeredDiff8thOrder(f: (number: any) => number, x: number, h?: number): number;
+/**
+ * Return a numerical approximation of the integral
+ * of the function `f` from `a` to `b` using Monte Carlo integration.
+ *
+ * Thoughts for future improvements:
+ * - use a MISER algorithm to improve the accuracy
+ * - use a stratified sampling to improve the accuracy
+ * - use a quasi-Monte Carlo method to improve the accuracy
+ * - use a Markov Chain Monte Carlo method to improve the accuracy
+ * - use a Metropolis-Hastings algorithm to improve the accuracy
+ * - use a Hamiltonian Monte Carlo algorithm to improve the accuracy
+ * - use a Gibbs sampling algorithm to improve the accuracy
+ *
+ *
+ * See:
+ * - https://64.github.io/monte-carlo/
+ *
+ */
+export declare function monteCarloEstimate(f: (x: number) => number, a: number, b: number, n?: number): number;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.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];