New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

gmp-wasm

Package Overview
Dependencies
Maintainers
1
Versions
15
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

gmp-wasm - npm Package Compare versions

Comparing version 0.8.0 to 0.8.1

304

dist/types/src/float.d.ts

@@ -1,2 +0,2 @@

import type { GMPFunctions, mpfr_rnd_t } from './functions';
import type { GMPFunctions } from './functions';
import { Integer } from './integer';

@@ -11,9 +11,17 @@ import { Rational } from './rational';

declare type AllTypes = Integer | Rational | Float | number;
/** Represents the different rounding modes. */
export declare enum FloatRoundingMode {
/** Round to nearest, with ties to even. MPFR_RNDN */
ROUND_TO_NEAREST_TIES_TO_EVEN = 0,
/** Round toward zero. MPFR_RNDZ */
ROUND_TOWARD_ZERO = 1,
/** Round toward +Infinity. MPFR_RNDU */
ROUND_TOWARD_INF = 2,
/** Round toward -Infinity. MPFR_RNDD */
ROUND_TOWARD_NEG_INF = 3,
/** Round away from zero. MPFR_RNDA */
ROUND_AWAY_FROM_ZERO = 4,
/** Faithful rounding. MPFR_RNDF */
ROUND_FAITHFUL = 5,
/** Round to nearest, with ties away from zero. MPFR_RNDNA */
ROUND_TO_NEAREST_AWAY_FROM_ZERO = -1

@@ -25,8 +33,10 @@ }

}
export declare function getFloatContext(gmp: GMPFunctions, ctx: any, options?: FloatOptions): {
Float: (val?: string | number | Float | Rational | Integer, options?: FloatOptions) => {
export declare function getFloatContext(gmp: GMPFunctions, ctx: any, ctxOptions?: FloatOptions): {
Float: (val?: null | undefined | string | number | Float | Rational | Integer, options?: FloatOptions) => {
mpfr_t: number;
precisionBits: number;
rndMode: mpfr_rnd_t;
rndMode: number;
type: string;
readonly options: FloatOptions;
readonly setOptions: FloatOptions;
add(val: AllTypes): Float;

@@ -43,2 +53,3 @@ sub(val: AllTypes): Float;

factorial(): any;
isInteger(): boolean;
isZero(): boolean;

@@ -79,16 +90,69 @@ isRegular(): boolean;

atanh(): Float;
/** Calculate exponential integral */
eint(): Float;
/** Calculate the real part of the dilogarithm (the integral of -log(1-t)/t from 0 to op) */
li2(): Float;
/** Calculate the value of the Gamma function. */
gamma(): Float;
/** Calculate the value of the logarithm of the absolute value of the Gamma function */
lngamma(): Float;
/** Calculate the value of the Digamma (sometimes also called Psi) function */
digamma(): Float;
/** Calculate the value of the Beta function */
beta(op2: Float): Float;
/** Calculate the value of the Riemann Zeta function */
zeta(): Float;
/** Calculate the value of the error function */
erf(): Float;
/** Calculate the value of the complementary error function */
erfc(): Float;
/** Calculate the value of the first kind Bessel function of order 0 */
j0(): Float;
/** Calculate the value of the first kind Bessel function of order 1 */
j1(): Float;
/** Calculate the value of the first kind Bessel function of order n */
jn(n: number): Float;
/** Calculate the value of the second kind Bessel function of order 0 */
y0(): Float;
/** Calculate the value of the second kind Bessel function of order 1 */
y1(): Float;
/** Calculate the value of the second kind Bessel function of order n */
yn(n: number): Float;
/** Calculate the arithmetic-geometric mean */
agm(op2: Float): Float;
/** Calculate the value of the Airy function Ai on x */
ai(): Float;
sign(): number;
toNumber(): number;
/** Rounds to the next higher or equal representable integer */
ceil(): Float;
/** Rounds to the next lower or equal representable integer */
floor(): Float;
/** Rounds to the nearest representable integer, rounding halfway cases away from zero */
round(): Float;
/** Rounds to the nearest representable integer, rounding halfway cases with the even-rounding rule */
roundeven(): Float;
/** Rounds to the next representable integer toward zero */
trunc(): Float;
/** Round to precision */
roundTo(prec: number): Float;
/** Returns the fractional part */
frac(): Float;
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded toward zero */
fmod(y: Float): Float;
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded to the nearest integer (ties rounded to even) */
remainder(y: Float): Float;
nextAbove(): Float;
nextBelow(): Float;
exponent2(): number;
toString(): string;
};
isFloat: (val: any) => boolean;
Pi: () => {
Pi: (options?: FloatOptions) => {
mpfr_t: number;
precisionBits: number;
rndMode: mpfr_rnd_t;
rndMode: number;
type: string;
readonly options: FloatOptions;
readonly setOptions: FloatOptions;
add(val: AllTypes): Float;

@@ -105,2 +169,3 @@ sub(val: AllTypes): Float;

factorial(): any;
isInteger(): boolean;
isZero(): boolean;

@@ -141,15 +206,68 @@ isRegular(): boolean;

atanh(): Float;
/** Calculate exponential integral */
eint(): Float;
/** Calculate the real part of the dilogarithm (the integral of -log(1-t)/t from 0 to op) */
li2(): Float;
/** Calculate the value of the Gamma function. */
gamma(): Float;
/** Calculate the value of the logarithm of the absolute value of the Gamma function */
lngamma(): Float;
/** Calculate the value of the Digamma (sometimes also called Psi) function */
digamma(): Float;
/** Calculate the value of the Beta function */
beta(op2: Float): Float;
/** Calculate the value of the Riemann Zeta function */
zeta(): Float;
/** Calculate the value of the error function */
erf(): Float;
/** Calculate the value of the complementary error function */
erfc(): Float;
/** Calculate the value of the first kind Bessel function of order 0 */
j0(): Float;
/** Calculate the value of the first kind Bessel function of order 1 */
j1(): Float;
/** Calculate the value of the first kind Bessel function of order n */
jn(n: number): Float;
/** Calculate the value of the second kind Bessel function of order 0 */
y0(): Float;
/** Calculate the value of the second kind Bessel function of order 1 */
y1(): Float;
/** Calculate the value of the second kind Bessel function of order n */
yn(n: number): Float;
/** Calculate the arithmetic-geometric mean */
agm(op2: Float): Float;
/** Calculate the value of the Airy function Ai on x */
ai(): Float;
sign(): number;
toNumber(): number;
/** Rounds to the next higher or equal representable integer */
ceil(): Float;
/** Rounds to the next lower or equal representable integer */
floor(): Float;
/** Rounds to the nearest representable integer, rounding halfway cases away from zero */
round(): Float;
/** Rounds to the nearest representable integer, rounding halfway cases with the even-rounding rule */
roundeven(): Float;
/** Rounds to the next representable integer toward zero */
trunc(): Float;
/** Round to precision */
roundTo(prec: number): Float;
/** Returns the fractional part */
frac(): Float;
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded toward zero */
fmod(y: Float): Float;
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded to the nearest integer (ties rounded to even) */
remainder(y: Float): Float;
nextAbove(): Float;
nextBelow(): Float;
exponent2(): number;
toString(): string;
};
EulerConstant: () => {
EulerConstant: (options?: FloatOptions) => {
mpfr_t: number;
precisionBits: number;
rndMode: mpfr_rnd_t;
rndMode: number;
type: string;
readonly options: FloatOptions;
readonly setOptions: FloatOptions;
add(val: AllTypes): Float;

@@ -166,2 +284,3 @@ sub(val: AllTypes): Float;

factorial(): any;
isInteger(): boolean;
isZero(): boolean;

@@ -202,16 +321,69 @@ isRegular(): boolean;

atanh(): Float;
/** Calculate exponential integral */
eint(): Float;
/** Calculate the real part of the dilogarithm (the integral of -log(1-t)/t from 0 to op) */
li2(): Float;
/** Calculate the value of the Gamma function. */
gamma(): Float;
/** Calculate the value of the logarithm of the absolute value of the Gamma function */
lngamma(): Float;
/** Calculate the value of the Digamma (sometimes also called Psi) function */
digamma(): Float;
/** Calculate the value of the Beta function */
beta(op2: Float): Float;
/** Calculate the value of the Riemann Zeta function */
zeta(): Float;
/** Calculate the value of the error function */
erf(): Float;
/** Calculate the value of the complementary error function */
erfc(): Float;
/** Calculate the value of the first kind Bessel function of order 0 */
j0(): Float;
/** Calculate the value of the first kind Bessel function of order 1 */
j1(): Float;
/** Calculate the value of the first kind Bessel function of order n */
jn(n: number): Float;
/** Calculate the value of the second kind Bessel function of order 0 */
y0(): Float;
/** Calculate the value of the second kind Bessel function of order 1 */
y1(): Float;
/** Calculate the value of the second kind Bessel function of order n */
yn(n: number): Float;
/** Calculate the arithmetic-geometric mean */
agm(op2: Float): Float;
/** Calculate the value of the Airy function Ai on x */
ai(): Float;
sign(): number;
toNumber(): number;
/** Rounds to the next higher or equal representable integer */
ceil(): Float;
/** Rounds to the next lower or equal representable integer */
floor(): Float;
/** Rounds to the nearest representable integer, rounding halfway cases away from zero */
round(): Float;
/** Rounds to the nearest representable integer, rounding halfway cases with the even-rounding rule */
roundeven(): Float;
/** Rounds to the next representable integer toward zero */
trunc(): Float;
/** Round to precision */
roundTo(prec: number): Float;
/** Returns the fractional part */
frac(): Float;
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded toward zero */
fmod(y: Float): Float;
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded to the nearest integer (ties rounded to even) */
remainder(y: Float): Float;
nextAbove(): Float;
nextBelow(): Float;
exponent2(): number;
toString(): string;
};
EulerNumber: () => Float;
Log2: () => {
EulerNumber: (options?: FloatOptions) => Float;
Log2: (options?: FloatOptions) => {
mpfr_t: number;
precisionBits: number;
rndMode: mpfr_rnd_t;
rndMode: number;
type: string;
readonly options: FloatOptions;
readonly setOptions: FloatOptions;
add(val: AllTypes): Float;

@@ -228,2 +400,3 @@ sub(val: AllTypes): Float;

factorial(): any;
isInteger(): boolean;
isZero(): boolean;

@@ -264,15 +437,68 @@ isRegular(): boolean;

atanh(): Float;
/** Calculate exponential integral */
eint(): Float;
/** Calculate the real part of the dilogarithm (the integral of -log(1-t)/t from 0 to op) */
li2(): Float;
/** Calculate the value of the Gamma function. */
gamma(): Float;
/** Calculate the value of the logarithm of the absolute value of the Gamma function */
lngamma(): Float;
/** Calculate the value of the Digamma (sometimes also called Psi) function */
digamma(): Float;
/** Calculate the value of the Beta function */
beta(op2: Float): Float;
/** Calculate the value of the Riemann Zeta function */
zeta(): Float;
/** Calculate the value of the error function */
erf(): Float;
/** Calculate the value of the complementary error function */
erfc(): Float;
/** Calculate the value of the first kind Bessel function of order 0 */
j0(): Float;
/** Calculate the value of the first kind Bessel function of order 1 */
j1(): Float;
/** Calculate the value of the first kind Bessel function of order n */
jn(n: number): Float;
/** Calculate the value of the second kind Bessel function of order 0 */
y0(): Float;
/** Calculate the value of the second kind Bessel function of order 1 */
y1(): Float;
/** Calculate the value of the second kind Bessel function of order n */
yn(n: number): Float;
/** Calculate the arithmetic-geometric mean */
agm(op2: Float): Float;
/** Calculate the value of the Airy function Ai on x */
ai(): Float;
sign(): number;
toNumber(): number;
/** Rounds to the next higher or equal representable integer */
ceil(): Float;
/** Rounds to the next lower or equal representable integer */
floor(): Float;
/** Rounds to the nearest representable integer, rounding halfway cases away from zero */
round(): Float;
/** Rounds to the nearest representable integer, rounding halfway cases with the even-rounding rule */
roundeven(): Float;
/** Rounds to the next representable integer toward zero */
trunc(): Float;
/** Round to precision */
roundTo(prec: number): Float;
/** Returns the fractional part */
frac(): Float;
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded toward zero */
fmod(y: Float): Float;
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded to the nearest integer (ties rounded to even) */
remainder(y: Float): Float;
nextAbove(): Float;
nextBelow(): Float;
exponent2(): number;
toString(): string;
};
Catalan: () => {
Catalan: (options?: FloatOptions) => {
mpfr_t: number;
precisionBits: number;
rndMode: mpfr_rnd_t;
rndMode: number;
type: string;
readonly options: FloatOptions;
readonly setOptions: FloatOptions;
add(val: AllTypes): Float;

@@ -289,2 +515,3 @@ sub(val: AllTypes): Float;

factorial(): any;
isInteger(): boolean;
isZero(): boolean;

@@ -325,8 +552,59 @@ isRegular(): boolean;

atanh(): Float;
/** Calculate exponential integral */
eint(): Float;
/** Calculate the real part of the dilogarithm (the integral of -log(1-t)/t from 0 to op) */
li2(): Float;
/** Calculate the value of the Gamma function. */
gamma(): Float;
/** Calculate the value of the logarithm of the absolute value of the Gamma function */
lngamma(): Float;
/** Calculate the value of the Digamma (sometimes also called Psi) function */
digamma(): Float;
/** Calculate the value of the Beta function */
beta(op2: Float): Float;
/** Calculate the value of the Riemann Zeta function */
zeta(): Float;
/** Calculate the value of the error function */
erf(): Float;
/** Calculate the value of the complementary error function */
erfc(): Float;
/** Calculate the value of the first kind Bessel function of order 0 */
j0(): Float;
/** Calculate the value of the first kind Bessel function of order 1 */
j1(): Float;
/** Calculate the value of the first kind Bessel function of order n */
jn(n: number): Float;
/** Calculate the value of the second kind Bessel function of order 0 */
y0(): Float;
/** Calculate the value of the second kind Bessel function of order 1 */
y1(): Float;
/** Calculate the value of the second kind Bessel function of order n */
yn(n: number): Float;
/** Calculate the arithmetic-geometric mean */
agm(op2: Float): Float;
/** Calculate the value of the Airy function Ai on x */
ai(): Float;
sign(): number;
toNumber(): number;
/** Rounds to the next higher or equal representable integer */
ceil(): Float;
/** Rounds to the next lower or equal representable integer */
floor(): Float;
/** Rounds to the nearest representable integer, rounding halfway cases away from zero */
round(): Float;
/** Rounds to the nearest representable integer, rounding halfway cases with the even-rounding rule */
roundeven(): Float;
/** Rounds to the next representable integer toward zero */
trunc(): Float;
/** Round to precision */
roundTo(prec: number): Float;
/** Returns the fractional part */
frac(): Float;
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded toward zero */
fmod(y: Float): Float;
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded to the nearest integer (ties rounded to even) */
remainder(y: Float): Float;
nextAbove(): Float;
nextBelow(): Float;
exponent2(): number;
toString(): string;

@@ -333,0 +611,0 @@ };

523

dist/types/src/index.d.ts

@@ -11,7 +11,7 @@ import { Float, FloatFactory, FloatOptions, FloatRoundingMode } from './float';

Float: FloatFactory;
Pi: () => Float;
EulerConstant: () => Float;
EulerNumber: () => Float;
Log2: () => Float;
Catalan: () => Float;
Pi: (options?: FloatOptions) => Float;
EulerConstant: (options?: FloatOptions) => Float;
EulerNumber: (options?: FloatOptions) => Float;
Log2: (options?: FloatOptions) => Float;
Catalan: (options?: FloatOptions) => Float;
}

@@ -21,510 +21,11 @@ export interface CalculateTypeWithDestroy extends CalculateType {

}
export interface GMPLib {
binding: GMPFunctions;
calculate: (fn: (gmp: CalculateType) => Integer | Rational | Float, options?: CalculateOptions) => void;
getContext: (options?: CalculateOptions) => CalculateTypeWithDestroy;
reset: () => Promise<void>;
}
export interface CalculateOptions extends FloatOptions {
}
export declare function init(): Promise<{
binding: {
reset: () => Promise<void>;
malloc: (size: number) => number;
malloc_cstr: (str: string) => number;
free: (ptr: number) => void;
readonly mem: Uint8Array;
readonly memView: DataView;
gmp_randinit_default: (state: number) => void;
gmp_randinit_lc_2exp: (state: number, a: number, c: number, m2exp: number) => void;
gmp_randinit_lc_2exp_size: (state: number, size: number) => number;
gmp_randinit_mt: (state: number) => void;
gmp_randinit_set: (rop: number, op: number) => void;
gmp_randseed: (state: number, seed: number) => void;
gmp_randseed_ui: (state: number, seed: number) => void;
gmp_randclear: (state: number) => void;
gmp_urandomb_ui: (state: number, n: number) => number;
gmp_urandomm_ui: (state: number, n: number) => number;
mp_bits_per_limb: () => number;
mpz_t: () => number;
mpz_t_free: (ptr: number) => void;
mpz_t_frees: (...ptrs: number[]) => void;
mpz_abs: (rop: number, op: number) => void;
mpz_add: (rop: number, op1: number, op2: number) => void;
mpz_add_ui: (rop: number, op1: number, op2: number) => void;
mpz_addmul: (rop: number, op1: number, op2: number) => void;
mpz_addmul_ui: (rop: number, op1: number, op2: number) => void;
mpz_and: (rop: number, op1: number, op2: number) => void;
mpz_bin_ui: (rop: number, n: number, k: number) => void;
mpz_bin_uiui: (rop: number, n: number, k: number) => void;
mpz_cdiv_q: (q: number, n: number, d: number) => void;
mpz_cdiv_q_2exp: (q: number, n: number, b: number) => void;
mpz_cdiv_q_ui: (q: number, n: number, d: number) => number;
mpz_cdiv_qr: (q: number, r: number, n: number, d: number) => void;
mpz_cdiv_qr_ui: (q: number, r: number, n: number, d: number) => number;
mpz_cdiv_r: (r: number, n: number, d: number) => void;
mpz_cdiv_r_2exp: (r: number, n: number, b: number) => void;
mpz_cdiv_r_ui: (r: number, n: number, d: number) => number;
mpz_cdiv_ui: (n: number, d: number) => number;
mpz_clear: (x: number) => void;
mpz_clears: (...ptrs: number[]) => void;
mpz_clrbit: (rop: number, bit_index: number) => void;
mpz_cmp: (op1: number, op2: number) => number;
mpz_cmp_d: (op1: number, op2: number) => number;
mpz_cmp_si: (op1: number, op2: number) => number;
mpz_cmp_ui: (op1: number, op2: number) => number;
mpz_cmpabs: (op1: number, op2: number) => number;
mpz_cmpabs_d: (op1: number, op2: number) => number;
mpz_cmpabs_ui: (op1: number, op2: number) => number;
mpz_com: (rop: number, op: number) => void;
mpz_combit: (rop: number, bitIndex: number) => void;
mpz_congruent_p: (n: number, c: number, d: number) => number;
mpz_congruent_2exp_p: (n: number, c: number, b: number) => number;
mpz_congruent_ui_p: (n: number, c: number, d: number) => number;
mpz_divexact: (q: number, n: number, d: number) => void;
mpz_divexact_ui: (q: number, n: number, d: number) => void;
mpz_divisible_p: (n: number, d: number) => number;
mpz_divisible_ui_p: (n: number, d: number) => number;
mpz_divisible_2exp_p: (n: number, b: number) => number;
mpz_even_p: (op: number) => void;
mpz_export: (rop: number, countp: number, order: number, size: number, endian: number, nails: number, op: number) => number;
mpz_fac_ui: (rop: number, n: number) => void;
mpz_2fac_ui: (rop: number, n: number) => void;
mpz_mfac_uiui: (rop: number, n: number, m: number) => void;
mpz_primorial_ui: (rop: number, n: number) => void;
mpz_fdiv_q: (q: number, n: number, d: number) => void;
mpz_fdiv_q_2exp: (q: number, n: number, b: number) => void;
mpz_fdiv_q_ui: (q: number, n: number, d: number) => number;
mpz_fdiv_qr: (q: number, r: number, n: number, d: number) => void;
mpz_fdiv_qr_ui: (q: number, r: number, n: number, d: number) => number;
mpz_fdiv_r: (r: number, n: number, d: number) => void;
mpz_fdiv_r_2exp: (r: number, n: number, b: number) => void;
mpz_fdiv_r_ui: (r: number, n: number, d: number) => number;
mpz_fdiv_ui: (n: number, d: number) => number;
mpz_fib_ui: (fn: number, n: number) => void;
mpz_fib2_ui: (fn: number, fnsub1: number, n: number) => void;
mpz_fits_sint_p: (op: number) => number;
mpz_fits_slong_p: (op: number) => number;
mpz_fits_sshort_p: (op: number) => number;
mpz_fits_uint_p: (op: number) => number;
mpz_fits_ulong_p: (op: number) => number;
mpz_fits_ushort_p: (op: number) => number;
mpz_gcd: (rop: number, op1: number, op2: number) => void;
mpz_gcd_ui: (rop: number, op1: number, op2: number) => number;
mpz_gcdext: (g: number, s: number, t: number, a: number, b: number) => void;
mpz_get_d: (op: number) => number;
mpz_get_d_2exp: (exp: number, op: number) => number;
mpz_get_si: (op: number) => number;
mpz_get_str: (str: number, base: number, op: number) => number;
mpz_get_ui: (op: number) => number;
mpz_getlimbn: (op: number, n: number) => number;
mpz_hamdist: (op1: number, op2: number) => number;
mpz_import: (rop: number, count: number, order: number, size: number, endian: number, nails: number, op: number) => void;
mpz_init: (x: number) => void;
mpz_inits: (...ptrs: number[]) => void;
mpz_init2: (x: number, n: number) => void;
mpz_init_set: (rop: number, op: number) => void;
mpz_init_set_d: (rop: number, op: number) => void;
mpz_init_set_si: (rop: number, op: number) => void;
mpz_init_set_str: (rop: number, str: number, base: number) => number;
mpz_init_set_ui: (rop: number, op: number) => void;
mpz_invert: (rop: number, op1: number, op2: number) => number;
mpz_ior: (rop: number, op1: number, op2: number) => void;
mpz_jacobi: (a: number, b: number) => number;
mpz_kronecker: (a: number, b: number) => number;
mpz_kronecker_si: (a: number, b: number) => number;
mpz_kronecker_ui: (a: number, b: number) => number;
mpz_si_kronecker: (a: number, b: number) => number;
mpz_ui_kronecker: (a: number, b: number) => number;
mpz_lcm: (rop: number, op1: number, op2: number) => void;
mpz_lcm_ui: (rop: number, op1: number, op2: number) => void;
mpz_legendre: (a: number, p: number) => number;
mpz_lucnum_ui: (ln: number, n: number) => void;
mpz_lucnum2_ui: (ln: number, lnsub1: number, n: number) => void;
mpz_millerrabin: (n: number, reps: number) => number;
mpz_mod: (r: number, n: number, d: number) => void;
mpz_mod_ui: (r: number, n: number, d: number) => void;
mpz_mul: (rop: number, op1: number, op2: number) => void;
mpz_mul_2exp: (rop: number, op1: number, op2: number) => void;
mpz_mul_si: (rop: number, op1: number, op2: number) => void;
mpz_mul_ui: (rop: number, op1: number, op2: number) => void;
mpz_neg: (rop: number, op: number) => void;
mpz_nextprime: (rop: number, op: number) => void;
mpz_odd_p: (op: number) => void;
mpz_perfect_power_p: (op: number) => number;
mpz_perfect_square_p: (op: number) => number;
mpz_popcount: (op: number) => number;
mpz_pow_ui: (rop: number, base: number, exp: number) => void;
mpz_powm: (rop: number, base: number, exp: number, mod: number) => void;
mpz_powm_sec: (rop: number, base: number, exp: number, mod: number) => void;
mpz_powm_ui: (rop: number, base: number, exp: number, mod: number) => void;
mpz_probab_prime_p: (n: number, reps: number) => number;
mpz_random: (rop: number, maxSize: number) => void;
mpz_random2: (rop: number, maxSize: number) => void;
mpz_realloc2: (x: number, n: number) => void;
mpz_remove: (rop: number, op: number, f: number) => number;
mpz_root: (rop: number, op: number, n: number) => number;
mpz_rootrem: (root: number, rem: number, u: number, n: number) => void;
mpz_rrandomb: (rop: number, state: number, n: number) => void;
mpz_scan0: (op: number, startingBit: number) => number;
mpz_scan1: (op: number, startingBit: number) => number;
mpz_set: (rop: number, op: number) => void;
mpz_set_d: (rop: number, op: number) => void;
mpz_set_q: (rop: number, op: number) => void;
mpz_set_si: (rop: number, op: number) => void;
mpz_set_str: (rop: number, str: number, base: number) => number;
mpz_set_ui: (rop: number, op: number) => void;
mpz_setbit: (rop: number, bitIndex: number) => void;
mpz_sgn: (op: number) => number;
mpz_size: (op: number) => number;
mpz_sizeinbase: (op: number, base: number) => number;
mpz_sqrt: (rop: number, op: number) => void;
mpz_sqrtrem: (rop1: number, rop2: number, op: number) => void;
mpz_sub: (rop: number, op1: number, op2: number) => void;
mpz_sub_ui: (rop: number, op1: number, op2: number) => void;
mpz_ui_sub: (rop: number, op1: number, op2: number) => void;
mpz_submul: (rop: number, op1: number, op2: number) => void;
mpz_submul_ui: (rop: number, op1: number, op2: number) => void;
mpz_swap: (rop1: number, rop2: number) => void;
mpz_tdiv_ui: (n: number, d: number) => number;
mpz_tdiv_q: (q: number, n: number, d: number) => void;
mpz_tdiv_q_2exp: (q: number, n: number, b: number) => void;
mpz_tdiv_q_ui: (q: number, n: number, d: number) => number;
mpz_tdiv_qr: (q: number, r: number, n: number, d: number) => void;
mpz_tdiv_qr_ui: (q: number, r: number, n: number, d: number) => number;
mpz_tdiv_r: (r: number, n: number, d: number) => void;
mpz_tdiv_r_2exp: (r: number, n: number, b: number) => void;
mpz_tdiv_r_ui: (r: number, n: number, d: number) => number;
mpz_tstbit: (op: number, bitIndex: number) => number;
mpz_ui_pow_ui: (rop: number, base: number, exp: number) => void;
mpz_urandomb: (rop: number, state: number, n: number) => void;
mpz_urandomm: (rop: number, state: number, n: number) => void;
mpz_xor: (rop: number, op1: number, op2: number) => void;
mpz_limbs_read: (x: number) => number;
mpz_limbs_write: (x: number, n: number) => number;
mpz_limbs_modify: (x: number, n: number) => number;
mpz_limbs_finish: (x: number, s: number) => void;
mpz_roinit_n: (x: number, xp: number, xs: number) => number;
mpq_t: () => number;
mpq_t_free: (mpq_ptr: number) => void;
mpq_t_frees: (...ptrs: number[]) => void;
mpq_abs: (rop: number, op: number) => void;
mpq_add: (sum: number, addend1: number, addend2: number) => void;
mpq_canonicalize: (op: number) => void;
mpq_clear: (x: number) => void;
mpq_clears: (...ptrs: number[]) => void;
mpq_cmp: (op1: number, op2: number) => number;
mpq_cmp_si: (op1: number, num2: number, den2: number) => number;
mpq_cmp_ui: (op1: number, num2: number, den2: number) => number;
mpq_cmp_z: (op1: number, op2: number) => number;
mpq_div: (quotient: number, dividend: number, divisor: number) => void;
mpq_div_2exp: (rop: number, op1: number, op2: number) => void;
mpq_equal: (op1: number, op2: number) => number;
mpq_get_num: (numerator: number, rational: number) => void;
mpq_get_den: (denominator: number, rational: number) => void;
mpq_get_d: (op: number) => number;
mpq_get_str: (str: number, base: number, op: number) => number;
mpq_init: (x: number) => void;
mpq_inits: (...ptrs: number[]) => void;
mpq_inv: (inverted_number: number, number: number) => void;
mpq_mul: (product: number, multiplier: number, multiplicand: number) => void;
mpq_mul_2exp: (rop: number, op1: number, op2: number) => void;
mpq_neg: (negated_operand: number, operand: number) => void;
mpq_set: (rop: number, op: number) => void;
mpq_set_d: (rop: number, op: number) => void;
mpq_set_den: (rational: number, denominator: number) => void;
mpq_set_num: (rational: number, numerator: number) => void;
mpq_set_si: (rop: number, op1: number, op2: number) => void;
mpq_set_str: (rop: number, str: number, base: number) => number;
mpq_set_ui: (rop: number, op1: number, op2: number) => void;
mpq_set_z: (rop: number, op: number) => void;
mpq_sgn: (op: number) => number;
mpq_sub: (difference: number, minuend: number, subtrahend: number) => void;
mpq_swap: (rop1: number, rop2: number) => void;
mpfr_t: () => number;
mpfr_t_free: (mpfr_ptr: number) => void;
mpfr_t_frees: (...ptrs: number[]) => void;
mpfr_get_version: () => number;
mpfr_get_patches: () => number;
mpfr_buildopt_tls_p: () => number;
mpfr_buildopt_float128_p: () => number;
mpfr_buildopt_decimal_p: () => number;
mpfr_buildopt_gmpinternals_p: () => number;
mpfr_buildopt_sharedcache_p: () => number;
mpfr_buildopt_tune_case: () => number;
mpfr_get_emin: () => number;
mpfr_set_emin: (exp: number) => number;
mpfr_get_emin_min: () => number;
mpfr_get_emin_max: () => number;
mpfr_get_emax: () => number;
mpfr_set_emax: (exp: number) => number;
mpfr_get_emax_min: () => number;
mpfr_get_emax_max: () => number;
mpfr_set_default_rounding_mode: (rnd: import("./functions").mpfr_rnd_t) => void;
mpfr_get_default_rounding_mode: () => import("./functions").mpfr_rnd_t;
mpfr_print_rnd_mode: (rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_clear_flags: () => void;
mpfr_clear_underflow: () => void;
mpfr_clear_overflow: () => void;
mpfr_clear_divby0: () => void;
mpfr_clear_nanflag: () => void;
mpfr_clear_inexflag: () => void;
mpfr_clear_erangeflag: () => void;
mpfr_set_underflow: () => void;
mpfr_set_overflow: () => void;
mpfr_set_divby0: () => void;
mpfr_set_nanflag: () => void;
mpfr_set_inexflag: () => void;
mpfr_set_erangeflag: () => void;
mpfr_underflow_p: () => number;
mpfr_overflow_p: () => number;
mpfr_divby0_p: () => number;
mpfr_nanflag_p: () => number;
mpfr_inexflag_p: () => number;
mpfr_erangeflag_p: () => number;
mpfr_flags_clear: (mask: number) => void;
mpfr_flags_set: (mask: number) => void;
mpfr_flags_test: (mask: number) => number;
mpfr_flags_save: () => number;
mpfr_flags_restore: (flags: number, mask: number) => void;
mpfr_check_range: (x: number, t: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_init2: (x: number, prec: number) => void;
mpfr_inits2: (prec: number, ...ptrs: number[]) => void;
mpfr_init: (x: number) => void;
mpfr_inits: (...ptrs: number[]) => void;
mpfr_clear: (x: number) => void;
mpfr_clears: (...ptrs: number[]) => void;
mpfr_prec_round: (x: number, prec: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_can_round: (b: number, err: number, rnd1: import("./functions").mpfr_rnd_t, rnd2: import("./functions").mpfr_rnd_t, prec: number) => number;
mpfr_min_prec: (x: number) => number;
mpfr_get_exp: (x: number) => number;
mpfr_set_exp: (x: number, e: number) => number;
mpfr_get_prec: (x: number) => number;
mpfr_set_prec: (x: number, prec: number) => void;
mpfr_set_prec_raw: (x: number, prec: number) => void;
mpfr_set_default_prec: (prec: number) => void;
mpfr_get_default_prec: () => number;
mpfr_set_d: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_set_z: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_set_z_2exp: (rop: number, op: number, e: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_set_nan: (x: number) => void;
mpfr_set_inf: (x: number, sign: number) => void;
mpfr_set_zero: (x: number, sign: number) => void;
mpfr_set_si: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_set_ui: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_set_si_2exp: (rop: number, op: number, e: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_set_ui_2exp: (rop: number, op: number, e: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_set_q: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_mul_q: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_div_q: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_add_q: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sub_q: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_cmp_q: (op1: number, op2: number) => number;
mpfr_get_q: (rop: number, op: number) => void;
mpfr_set_str: (rop: number, s: number, base: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_init_set: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => any;
mpfr_init_set_ui: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => any;
mpfr_init_set_si: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => any;
mpfr_init_set_d: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => any;
mpfr_init_set_z: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => any;
mpfr_init_set_q: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => any;
mpfr_init_set_str: (x: number, s: number, base: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_abs: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_set: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_neg: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_signbit: (op: number) => number;
mpfr_setsign: (rop: number, op: number, s: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_copysign: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_get_z_2exp: (rop: number, op: number) => number;
mpfr_get_d: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_get_d_2exp: (exp: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_frexp: (exp: number, y: number, x: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_get_si: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_get_ui: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_get_str_ndigits: (b: number, p: number) => number;
mpfr_get_str: (str: number, expptr: number, base: number, n: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_get_z: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_free_str: (str: number) => void;
mpfr_urandom: (rop: number, state: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_nrandom: (rop: number, state: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_erandom: (rop: number, state: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_urandomb: (rop: number, state: number) => number;
mpfr_nextabove: (x: number) => void;
mpfr_nextbelow: (x: number) => void;
mpfr_nexttoward: (x: number, y: number) => void;
mpfr_pow: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_pow_si: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_pow_ui: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_ui_pow_ui: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_ui_pow: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_pow_z: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sqrt: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sqrt_ui: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_rec_sqrt: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_add: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sub: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_mul: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_div: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_add_ui: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sub_ui: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_ui_sub: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_mul_ui: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_div_ui: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_ui_div: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_add_si: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sub_si: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_si_sub: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_mul_si: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_div_si: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_si_div: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_add_d: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sub_d: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_d_sub: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_mul_d: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_div_d: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_d_div: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sqr: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_const_pi: (rop: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_const_log2: (rop: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_const_euler: (rop: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_const_catalan: (rop: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_agm: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_log: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_log2: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_log10: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_log1p: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_log_ui: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_exp: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_exp2: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_exp10: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_expm1: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_eint: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_li2: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_cmp: (op1: number, op2: number) => number;
mpfr_cmp_d: (op1: number, op2: number) => number;
mpfr_cmp_ui: (op1: number, op2: number) => number;
mpfr_cmp_si: (op1: number, op2: number) => number;
mpfr_cmp_ui_2exp: (op1: number, op2: number, e: number) => number;
mpfr_cmp_si_2exp: (op1: number, op2: number, e: number) => number;
mpfr_cmpabs: (op1: number, op2: number) => number;
mpfr_cmpabs_ui: (op1: number, op2: number) => number;
mpfr_reldiff: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => void;
mpfr_eq: (op1: number, op2: number, op3: number) => number;
mpfr_sgn: (op: number) => number;
mpfr_mul_2exp: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_div_2exp: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_mul_2ui: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_div_2ui: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_mul_2si: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_div_2si: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_rint: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_roundeven: (rop: number, op: number) => number;
mpfr_round: (rop: number, op: number) => number;
mpfr_trunc: (rop: number, op: number) => number;
mpfr_ceil: (rop: number, op: number) => number;
mpfr_floor: (rop: number, op: number) => number;
mpfr_rint_roundeven: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_rint_round: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_rint_trunc: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_rint_ceil: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_rint_floor: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_frac: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_modf: (rop: number, fop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_remquo: (r: number, q: number, x: number, y: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_remainder: (rop: number, x: number, y: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fmod: (rop: number, x: number, y: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fmodquo: (rop: number, q: number, x: number, y: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fits_ulong_p: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fits_slong_p: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fits_uint_p: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fits_sint_p: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fits_ushort_p: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fits_sshort_p: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fits_uintmax_p: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fits_intmax_p: (op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_swap: (x: number, y: number) => void;
mpfr_dump: (op: number) => void;
mpfr_nan_p: (op: number) => number;
mpfr_inf_p: (op: number) => number;
mpfr_number_p: (op: number) => number;
mpfr_integer_p: (op: number) => number;
mpfr_zero_p: (op: number) => number;
mpfr_regular_p: (op: number) => number;
mpfr_greater_p: (op1: number, op2: number) => number;
mpfr_greaterequal_p: (op1: number, op2: number) => number;
mpfr_less_p: (op1: number, op2: number) => number;
mpfr_lessequal_p: (op1: number, op2: number) => number;
mpfr_lessgreater_p: (op1: number, op2: number) => number;
mpfr_equal_p: (op1: number, op2: number) => number;
mpfr_unordered_p: (op1: number, op2: number) => number;
mpfr_atanh: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_acosh: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_asinh: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_cosh: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sinh: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_tanh: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sinh_cosh: (sop: number, cop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sech: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_csch: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_coth: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_acos: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_asin: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_atan: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sin: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sin_cos: (sop: number, cop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_cos: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_tan: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_atan2: (rop: number, y: number, x: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sec: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_csc: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_cot: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_hypot: (rop: number, x: number, y: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_erf: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_erfc: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_cbrt: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_rootn_ui: (rop: number, op: number, k: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_gamma: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_gamma_inc: (rop: number, op: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_beta: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_lngamma: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_lgamma: (rop: number, signp: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_digamma: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_zeta: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_zeta_ui: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fac_ui: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_j0: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_j1: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_jn: (rop: number, n: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_y0: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_y1: (rop: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_yn: (rop: number, n: number, op: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_ai: (rop: number, x: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_min: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_max: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_dim: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_mul_z: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_div_z: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_add_z: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sub_z: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_z_sub: (rop: number, op1: number, op2: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_cmp_z: (op1: number, op2: number) => number;
mpfr_fma: (rop: number, op1: number, op2: number, op3: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fms: (rop: number, op1: number, op2: number, op3: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fmma: (rop: number, op1: number, op2: number, op3: number, op4: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_fmms: (rop: number, op1: number, op2: number, op3: number, op4: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_sum: (rop: number, tab: number, n: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_dot: (rop: number, a: number, b: number, n: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_free_cache: () => void;
mpfr_free_cache2: (way: import("./functions").mpfr_free_cache_t) => void;
mpfr_free_pool: () => void;
mpfr_mp_memory_cleanup: () => number;
mpfr_subnormalize: (x: number, t: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_strtofr: (rop: number, nptr: number, endptr: number, base: number, rnd: import("./functions").mpfr_rnd_t) => number;
mpfr_custom_get_size: (prec: number) => number;
mpfr_custom_init: (significand: number, prec: number) => void;
mpfr_custom_get_significand: (x: number) => number;
mpfr_custom_get_exp: (x: number) => number;
mpfr_custom_move: (x: number, new_position: number) => void;
mpfr_custom_init_set: (x: number, kind: number, exp: number, prec: number, significand: number) => void;
mpfr_custom_get_kind: (x: number) => number;
mpfr_total_order_p: (x: number, y: number) => number;
};
calculate: (fn: (gmp: CalculateType) => Integer | Rational | Float, options?: CalculateOptions) => string;
getContext: (options?: CalculateOptions) => CalculateTypeWithDestroy;
reset: () => Promise<void>;
}>;
export declare function init(): Promise<GMPLib>;
export declare const precisionToBits: (digits: number) => number;

2

package.json
{
"name": "gmp-wasm",
"version": "0.8.0",
"version": "0.8.1",
"description": "Arbitrary-precision Integer, Rational and Float types based on the GMP and MPFR libraries",

@@ -5,0 +5,0 @@ "main": "dist/index.umd.js",

62

README.md

@@ -6,3 +6,3 @@ # GMP-WASM

[![codecov](https://codecov.io/gh/Daninet/gmp-wasm/branch/master/graph/badge.svg)](https://codecov.io/gh/Daninet/gmp-wasm)
[![Build status](https://github.com/Daninet/gmp-wasm/workflows/Build%20&%20publish/badge.svg?branch=master)](https://github.com/Daninet/gmp-wasm/actions)
[![Build status](https://github.com/Daninet/gmp-wasm/workflows/Build/badge.svg?branch=master)](https://github.com/Daninet/gmp-wasm/actions)
[![JSDelivr downloads](https://data.jsdelivr.com/v1/package/npm/gmp-wasm/badge)](https://www.jsdelivr.com/package/npm/gmp-wasm)

@@ -20,4 +20,5 @@

- Works even without Webpack or other bundlers
- Includes TypeScript type definitions
- Includes TypeScript type definitions, check API [here](https://paka.dev/npm/gmp-wasm).
- Zero dependencies
- Minified and gzipped bundle has a size of [![Bundle size](https://badgen.net/bundlephobia/minzip/gmp-wasm)](https://bundlephobia.com/result?p=gmp-wasm)
- 100% open source & [transparent build process](https://github.com/Daninet/gmp-wasm/actions)

@@ -34,4 +35,7 @@

```html
<!-- loads the library into the global `gmp` variable -->
<!-- loads the minified library into the global `gmp` variable -->
<script src="https://cdn.jsdelivr.net/npm/gmp-wasm"></script>
<!-- or the non-minified library -->
<script src="https://cdn.jsdelivr.net/npm/gmp-wasm/dist/index.umd.js"></script>
```

@@ -75,4 +79,20 @@

## Constants
The precision and the rounding modes can be set by passing a parameter to the context or to the Float constructor.
```js
const gmp = require('gmp-wasm');
const roundingMode = gmp.FloatRoundingMode.ROUND_TOWARD_NEG_INF;
const options = { precisionBits: 10, roundingMode };
const result = calculate(g => g.Float(1).div(3), options);
// or
const result2 = calculate(g => g.Float(1, options).div(3));
// or
const ctx = getContext(options);
const result3 = ctx.Float(1).div(3).toString();
```
## Predefined constants
- gmp.Pi

@@ -120,3 +140,3 @@ - gmp.EulerConstant

Calculating 8000 digits of Pi using the following [formula](http://ajennings.net/blog/a-million-digits-of-pi-in-9-lines-of-javascript.html):
For example, calculating 8000 digits of Pi using the following [formula](http://ajennings.net/blog/a-million-digits-of-pi-in-9-lines-of-javascript.html) provides better results:

@@ -131,20 +151,20 @@ ```

| Test | Avg. time | Speedup | Notes |
|------------------------------|-------------|--------------|-------------------------------------------------------------------------------------|
| JS_BigInt_Series | 130.20 ms | 1x | With JS built-in `BigInt` type |
| GMP_BigInt_Series | 87.90 ms | 1.48x | **gmp-wasm** `Integer()` high-level wrapper |
| GMP_DelayGC_BigInt_Series | 78.88 ms | 1.65x | Same as previous with delayed memory deallocation |
| GMP_LowLevel_BigInt_Series | 53.93 ms | 2.41x | **gmp-wasm** `MPZ` low-level functions |
| DecimalJs_BigInt_Series | 426.99 ms | 0.30x | [decimal.js](https://www.npmjs.com/package/decimal.js) 10.3.1 with integer division |
| BigInteger_Series | 129.98 ms | 1x | [big-integer](https://www.npmjs.com/package/big-integer) 1.6.51 |
| ---------------------------- | -------- | -------- | --------------- |
| GMP_Float_Series | 198.31 ms | 0.66x | **gmp-wasm** `Float()` high-level wrapper |
| GMP_DelayGC_Float_Series | 191.94 ms | 0.68x | Same as previous with delayed memory deallocation |
| GMP_LowLevel_Float_Series | 135.49 ms | 0.96x | **gmp-wasm** `MPFR` low-level functions |
| DecimalJs_Float_Series | 764.15 ms | 0.17x | [decimal.js](https://www.npmjs.com/package/decimal.js) 10.3.1 with float division |
| ---------------------------- | -------- | -------- | --------------- |
| GMP_Atan_1 | 0.65 ms | 200.31x | **gmp-wasm** `Float(1).atan().mul(4)` |
| GMP_Asin_1over2 | 17.21 ms | 7.57x | **gmp-wasm** `Float('0.5').asin().mul(6)` |
| Test | Avg. time | Speedup |
|-------------------------------------------------------------------------------------|-----------|----------|
| With JS built-in `BigInt` type | 130.20 ms | 1x |
| **gmp-wasm** `Integer()` high-level wrapper | 87.90 ms | 1.48x |
| Same as previous with delayed memory deallocation | 78.88 ms | 1.65x |
| **gmp-wasm** `MPZ` low-level functions | 53.93 ms | 2.41x |
| [decimal.js](https://www.npmjs.com/package/decimal.js) 10.3.1 with integer division | 426.99 ms | 0.30x |
| [big-integer](https://www.npmjs.com/package/big-integer) 1.6.51 | 129.98 ms | 1x |
| ---------------------------- | -------- | -------- |
| **gmp-wasm** `Float()` high-level wrapper | 198.31 ms | 0.66x |
| Same as previous with delayed memory deallocation | 191.94 ms | 0.68x |
| **gmp-wasm** `MPFR` low-level functions | 135.49 ms | 0.96x |
| [decimal.js](https://www.npmjs.com/package/decimal.js) 10.3.1 with float division | 764.15 ms | 0.17x |
| ---------------------------- | -------- | -------- |
| **gmp-wasm** `Float(1).atan().mul(4)` | 0.65 ms | 200.31x |
| **gmp-wasm** `Float('0.5').asin().mul(6)` | 17.21 ms | 7.57x |
\* These measurements were made with `Node.js v16.13` on an Intel Kaby Lake desktop CPU. Source code is [here](https://github.com/Daninet/gmp-wasm/blob/master/benchmark/calcpi.js).

365

src/float.ts

@@ -17,9 +17,17 @@ import type { GMPFunctions, mpfr_rnd_t } from './functions';

// matches mpfr_rnd_t
/** Represents the different rounding modes. */
export enum FloatRoundingMode {
/** Round to nearest, with ties to even. MPFR_RNDN */
ROUND_TO_NEAREST_TIES_TO_EVEN = 0,
/** Round toward zero. MPFR_RNDZ */
ROUND_TOWARD_ZERO = 1,
/** Round toward +Infinity. MPFR_RNDU */
ROUND_TOWARD_INF = 2,
/** Round toward -Infinity. MPFR_RNDD */
ROUND_TOWARD_NEG_INF = 3,
/** Round away from zero. MPFR_RNDA */
ROUND_AWAY_FROM_ZERO = 4,
/** Faithful rounding. MPFR_RNDF */
ROUND_FAITHFUL = 5,
/** Round to nearest, with ties away from zero. MPFR_RNDNA */
ROUND_TO_NEAREST_AWAY_FROM_ZERO = -1,

@@ -85,3 +93,3 @@ };

export function getFloatContext(gmp: GMPFunctions, ctx: any, options?: FloatOptions) {
export function getFloatContext(gmp: GMPFunctions, ctx: any, ctxOptions?: FloatOptions) {
const mpfr_t_arr: number[] = [];

@@ -93,4 +101,4 @@

const globalRndMode = (options.roundingMode ?? FloatRoundingMode.ROUND_TO_NEAREST_TIES_TO_EVEN) as number as mpfr_rnd_t;
const globalPrecisionBits = options.precisionBits ?? 52;
const globalRndMode = (ctxOptions.roundingMode ?? FloatRoundingMode.ROUND_TO_NEAREST_TIES_TO_EVEN) as number as mpfr_rnd_t;
const globalPrecisionBits = ctxOptions.precisionBits ?? 52;
assertUint32(globalPrecisionBits);

@@ -115,11 +123,35 @@

const mergeFloatOptions = (options1: FloatOptions, options2: FloatOptions): FloatOptions => {
const precisionBits1 = options1?.precisionBits ?? globalPrecisionBits;
const precisionBits2 = options2?.precisionBits ?? globalPrecisionBits;
return {
precisionBits: Math.max(precisionBits1, precisionBits2),
roundingMode: options2?.roundingMode ?? options1.roundingMode ?? ctxOptions.roundingMode,
};
};
const FloatPrototype = {
mpfr_t: 0,
precisionBits: globalPrecisionBits,
rndMode: globalRndMode,
precisionBits: -1,
rndMode: -1,
type: 'float',
get options(): FloatOptions {
return {
precisionBits: this.precisionBits ?? globalPrecisionBits,
roundingMode: this.rndMode ?? globalRndMode,
};
},
get setOptions(): FloatOptions {
return {
precisionBits: this.precisionBits,
roundingMode: this.rndMode,
};
},
add(val: AllTypes): Float {
const n = FloatFn();
if (typeof val === 'number') {
const n = FloatFn(null, this.options);
gmp.mpfr_add_d(n.mpfr_t, this.mpfr_t, val, this.rndMode);

@@ -129,2 +161,3 @@ return n;

if (isFloat(val)) {
const n = FloatFn(null, mergeFloatOptions(this.setOptions, (val as Float).setOptions));
gmp.mpfr_add(n.mpfr_t, this.mpfr_t, (val as Float).mpfr_t, this.rndMode);

@@ -134,2 +167,3 @@ return n;

if (isRational(val)) {
const n = FloatFn(null, this.options);
gmp.mpfr_add_q(n.mpfr_t, this.mpfr_t, (val as Rational).mpq_t, this.rndMode);

@@ -139,2 +173,3 @@ return n;

if (isInteger(val)) {
const n = FloatFn(null, this.options);
gmp.mpfr_add_z(n.mpfr_t, this.mpfr_t, (val as Integer).mpz_t, this.rndMode);

@@ -147,4 +182,4 @@ return n;

sub(val: AllTypes): Float {
const n = FloatFn();
if (typeof val === 'number') {
const n = FloatFn(null, this.options);
gmp.mpfr_sub_d(n.mpfr_t, this.mpfr_t, val, this.rndMode);

@@ -154,2 +189,3 @@ return n;

if (isFloat(val)) {
const n = FloatFn(null, mergeFloatOptions(this.setOptions, (val as Float).setOptions));
gmp.mpfr_sub(n.mpfr_t, this.mpfr_t, (val as Float).mpfr_t, this.rndMode);

@@ -159,2 +195,3 @@ return n;

if (isRational(val)) {
const n = FloatFn(null, this.options);
gmp.mpfr_sub_q(n.mpfr_t, this.mpfr_t, (val as Rational).mpq_t, this.rndMode);

@@ -164,2 +201,3 @@ return n;

if (isInteger(val)) {
const n = FloatFn(null, this.options);
gmp.mpfr_sub_z(n.mpfr_t, this.mpfr_t, (val as Integer).mpz_t, this.rndMode);

@@ -172,4 +210,4 @@ return n;

mul(val: AllTypes): Float {
const n = FloatFn();
if (typeof val === 'number') {
const n = FloatFn(null, this.options);
if (isInt32(val)) {

@@ -183,2 +221,3 @@ gmp.mpfr_mul_si(n.mpfr_t, this.mpfr_t, val, this.rndMode);

if (isFloat(val)) {
const n = FloatFn(null, mergeFloatOptions(this.setOptions, (val as Float).setOptions));
gmp.mpfr_mul(n.mpfr_t, this.mpfr_t, (val as Float).mpfr_t, this.rndMode);

@@ -188,2 +227,3 @@ return n;

if (isRational(val)) {
const n = FloatFn(null, this.options);
gmp.mpfr_mul_q(n.mpfr_t, this.mpfr_t, (val as Rational).mpq_t, this.rndMode);

@@ -193,2 +233,3 @@ return n;

if (isInteger(val)) {
const n = FloatFn(null, this.options);
gmp.mpfr_mul_z(n.mpfr_t, this.mpfr_t, (val as Integer).mpz_t, this.rndMode);

@@ -201,4 +242,4 @@ return n;

div(val: AllTypes): Float {
const n = FloatFn();
if (typeof val === 'number') {
const n = FloatFn(null, this.options);
gmp.mpfr_div_d(n.mpfr_t, this.mpfr_t, val, this.rndMode);

@@ -208,2 +249,3 @@ return n;

if (isFloat(val)) {
const n = FloatFn(null, mergeFloatOptions(this.setOptions, (val as Float).setOptions));
gmp.mpfr_div(n.mpfr_t, this.mpfr_t, (val as Float).mpfr_t, this.rndMode);

@@ -213,2 +255,3 @@ return n;

if (isRational(val)) {
const n = FloatFn(null, this.options);
gmp.mpfr_div_q(n.mpfr_t, this.mpfr_t, (val as Rational).mpq_t, this.rndMode);

@@ -218,2 +261,3 @@ return n;

if (isInteger(val)) {
const n = FloatFn(null, this.options);
gmp.mpfr_div_z(n.mpfr_t, this.mpfr_t, (val as Integer).mpz_t, this.rndMode);

@@ -226,3 +270,3 @@ return n;

sqrt(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_sqrt(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -233,3 +277,3 @@ return n;

invSqrt(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_rec_sqrt(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -240,3 +284,3 @@ return n;

cbrt(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_cbrt(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -247,3 +291,3 @@ return n;

nthRoot(nth: number): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
assertUint32(nth);

@@ -255,3 +299,3 @@ gmp.mpfr_rootn_ui(n.mpfr_t, this.mpfr_t, nth, this.rndMode);

neg(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_neg(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -262,3 +306,3 @@ return n;

abs(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_abs(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -269,3 +313,3 @@ return n;

factorial() {
const n = FloatFn();
const n = FloatFn(null, this.options);
if (gmp.mpfr_fits_uint_p(this.mpfr_t, this.rndMode) === 0) {

@@ -279,2 +323,6 @@ throw new Error('Invalid value for factorial()');

isInteger() {
return gmp.mpfr_integer_p(this.mpfr_t) !== 0;
},
isZero() {

@@ -321,3 +369,3 @@ return gmp.mpfr_zero_p(this.mpfr_t) !== 0;

ln(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_log(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -328,3 +376,3 @@ return n;

log2(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_log2(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -335,3 +383,3 @@ return n;

log10(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_log10(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -342,3 +390,3 @@ return n;

exp(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_exp(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -349,3 +397,3 @@ return n;

exp2(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_exp2(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -356,3 +404,3 @@ return n;

exp10(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_exp10(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -363,3 +411,3 @@ return n;

pow(val: Float | number): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
if (typeof val === 'number') {

@@ -378,3 +426,3 @@ if (isInt32(val)) {

sin(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_sin(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -385,3 +433,3 @@ return n;

cos(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_cos(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -392,3 +440,3 @@ return n;

tan(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_tan(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -399,3 +447,3 @@ return n;

sec(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_sec(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -406,3 +454,3 @@ return n;

csc(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_csc(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -413,3 +461,3 @@ return n;

cot(): Float{
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_cot(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -420,3 +468,3 @@ return n;

acos(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_acos(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -427,3 +475,3 @@ return n;

asin(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_asin(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -434,3 +482,3 @@ return n;

atan(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_atan(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -441,3 +489,3 @@ return n;

sinh(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_sinh(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -448,3 +496,3 @@ return n;

cosh(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_cosh(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -455,3 +503,3 @@ return n;

tanh(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_tanh(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -462,3 +510,3 @@ return n;

sech(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_sech(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -469,3 +517,3 @@ return n;

csch(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_csch(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -476,3 +524,3 @@ return n;

coth(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_coth(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -483,3 +531,3 @@ return n;

acosh(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_acosh(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -490,3 +538,3 @@ return n;

asinh(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_asinh(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -497,3 +545,3 @@ return n;

atanh(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_atanh(n.mpfr_t, this.mpfr_t, this.rndMode);

@@ -503,2 +551,129 @@ return n;

/** Calculate exponential integral */
eint(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_eint(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the real part of the dilogarithm (the integral of -log(1-t)/t from 0 to op) */
li2(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_li2(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the Gamma function. */
gamma(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_gamma(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the logarithm of the absolute value of the Gamma function */
lngamma(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_lngamma(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the Digamma (sometimes also called Psi) function */
digamma(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_digamma(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the Beta function */
beta(op2: Float): Float {
if (!isFloat(op2)) {
throw new Error('Only floats parameters are supported!');
}
const n = FloatFn(null, this.options);
gmp.mpfr_beta(n.mpfr_t, this.mpfr_t, (op2 as Float).mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the Riemann Zeta function */
zeta(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_zeta(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the error function */
erf(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_erf(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the complementary error function */
erfc(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_erfc(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the first kind Bessel function of order 0 */
j0(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_j0(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the first kind Bessel function of order 1 */
j1(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_j1(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the first kind Bessel function of order n */
jn(n: number): Float {
assertInt32(n);
const rop = FloatFn(null, this.options);
gmp.mpfr_jn(rop.mpfr_t, n, this.mpfr_t, this.rndMode);
return rop;
},
/** Calculate the value of the second kind Bessel function of order 0 */
y0(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_y0(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the second kind Bessel function of order 1 */
y1(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_y1(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the second kind Bessel function of order n */
yn(n: number): Float {
assertInt32(n);
const rop = FloatFn(null, this.options);
gmp.mpfr_yn(rop.mpfr_t, n, this.mpfr_t, this.rndMode);
return rop;
},
/** Calculate the arithmetic-geometric mean */
agm(op2: Float): Float {
if (!isFloat(op2)) {
throw new Error('Only floats parameters are supported!');
}
const n = FloatFn(null, this.options);
gmp.mpfr_agm(n.mpfr_t, this.mpfr_t, (op2 as Float).mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of the Airy function Ai on x */
ai(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_ai(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
sign() {

@@ -509,11 +684,8 @@ return gmp.mpfr_sgn(this.mpfr_t);

toNumber() {
if (this.isNaN()) return NaN;
if (this.isInfinite()) {
return this.sign() * Infinity;
}
return gmp.mpfr_get_d(this.mpfr_t, this.rndMode);
},
/** Rounds to the next higher or equal representable integer */
ceil(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_ceil(n.mpfr_t, this.mpfr_t);

@@ -523,4 +695,5 @@ return n;

/** Rounds to the next lower or equal representable integer */
floor(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_floor(n.mpfr_t, this.mpfr_t);

@@ -530,4 +703,5 @@ return n;

/** Rounds to the nearest representable integer, rounding halfway cases away from zero */
round(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_round(n.mpfr_t, this.mpfr_t);

@@ -537,4 +711,12 @@ return n;

/** Rounds to the nearest representable integer, rounding halfway cases with the even-rounding rule */
roundeven(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_roundeven(n.mpfr_t, this.mpfr_t);
return n;
},
/** Rounds to the next representable integer toward zero */
trunc(): Float {
const n = FloatFn();
const n = FloatFn(null, this.options);
gmp.mpfr_trunc(n.mpfr_t, this.mpfr_t);

@@ -544,2 +726,53 @@ return n;

/** Round to precision */
roundTo(prec: number): Float {
assertUint32(prec);
const n = FloatFn(this, this.options);
gmp.mpfr_prec_round(this.mpfr_t, prec, this.rndMode);
return n;
},
/** Returns the fractional part */
frac(): Float {
const n = FloatFn(null, this.options);
gmp.mpfr_frac(n.mpfr_t, this.mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded toward zero */
fmod(y: Float): Float {
if (!isFloat(y)) {
throw new Error('Only floats parameters are supported!');
}
const n = FloatFn(null, this.options);
gmp.mpfr_fmod(n.mpfr_t, this.mpfr_t, (y as Float).mpfr_t, this.rndMode);
return n;
},
/** Calculate the value of x - ny, where n is the integer quotient of x divided by y; n is rounded to the nearest integer (ties rounded to even) */
remainder(y: Float): Float {
if (!isFloat(y)) {
throw new Error('Only floats parameters are supported!');
}
const n = FloatFn(null, this.options);
gmp.mpfr_remainder(n.mpfr_t, this.mpfr_t, (y as Float).mpfr_t, this.rndMode);
return n;
},
nextAbove(): Float {
const n = FloatFn(this, this.options);
gmp.mpfr_nextabove(n.mpfr_t);
return n;
},
nextBelow(): Float {
const n = FloatFn(this, this.options);
gmp.mpfr_nextbelow(n.mpfr_t);
return n;
},
exponent2() {
return gmp.mpfr_get_exp(this.mpfr_t);
},
toString() {

@@ -596,3 +829,3 @@ const mpfr_exp_t_ptr = gmp.malloc(4);

const FloatFn = (val?: string | number | Float | Rational | Integer, options?: FloatOptions) => {
const FloatFn = (val?: null | undefined | string | number | Float | Rational | Integer, options?: FloatOptions) => {
const rndMode = (options?.roundingMode ?? globalRndMode) as number as mpfr_rnd_t;

@@ -602,6 +835,8 @@ const precisionBits = options?.precisionBits ?? globalPrecisionBits;

const instance = Object.create(FloatPrototype) as typeof FloatPrototype;
instance.rndMode = rndMode;
instance.precisionBits = precisionBits;
instance.mpfr_t = gmp.mpfr_t();
gmp.mpfr_init2(instance.mpfr_t, precisionBits);
if (val !== undefined) {
if (val !== undefined && val !== null) {
setValue(instance.mpfr_t, rndMode, val);

@@ -618,27 +853,27 @@ }

Pi: () => {
const n = FloatFn();
gmp.mpfr_const_pi(n.mpfr_t, globalRndMode);
Pi: (options?: FloatOptions) => {
const n = FloatFn(null, options);
gmp.mpfr_const_pi(n.mpfr_t, (options?.roundingMode ?? globalRndMode) as mpfr_rnd_t);
return n;
},
EulerConstant: () => {
const n = FloatFn();
gmp.mpfr_const_euler(n.mpfr_t, globalRndMode);
EulerConstant: (options?: FloatOptions) => {
const n = FloatFn(null, options);
gmp.mpfr_const_euler(n.mpfr_t, (options?.roundingMode ?? globalRndMode) as mpfr_rnd_t);
return n;
},
EulerNumber: () => {
return FloatFn(1).exp();
EulerNumber: (options?: FloatOptions) => {
return FloatFn(1, options).exp();
},
Log2: () => {
const n = FloatFn();
gmp.mpfr_const_log2(n.mpfr_t, globalRndMode);
Log2: (options?: FloatOptions) => {
const n = FloatFn(null, options);
gmp.mpfr_const_log2(n.mpfr_t, (options?.roundingMode ?? globalRndMode) as mpfr_rnd_t);
return n;
},
Catalan: () => {
const n = FloatFn();
gmp.mpfr_const_catalan(n.mpfr_t, globalRndMode);
Catalan: (options?: FloatOptions) => {
const n = FloatFn(null, options);
gmp.mpfr_const_catalan(n.mpfr_t, (options?.roundingMode ?? globalRndMode) as mpfr_rnd_t);
return n;

@@ -645,0 +880,0 @@ },

26

src/index.ts

@@ -23,7 +23,7 @@ import { Float, FloatFactory, FloatOptions, FloatRoundingMode, getFloatContext } from './float';

Float: FloatFactory;
Pi: () => Float;
EulerConstant: () => Float;
EulerNumber: () => Float;
Log2: () => Float;
Catalan: () => Float;
Pi: (options?: FloatOptions) => Float;
EulerConstant: (options?: FloatOptions) => Float;
EulerNumber: (options?: FloatOptions) => Float;
Log2: (options?: FloatOptions) => Float;
Catalan: (options?: FloatOptions) => Float;
};

@@ -35,13 +35,13 @@

type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
export interface GMPLib {
binding: GMPFunctions;
calculate: (fn: (gmp: CalculateType) => Integer | Rational | Float, options?: CalculateOptions) => void;
getContext: (options?: CalculateOptions) => CalculateTypeWithDestroy;
reset: () => Promise<void>;
};
// export interface GMPLib {
// binding: Awaited<ReturnType<typeof getGMPInterface>>;
// calculate: (fn: (gmp: CalculateType) => Integer) => void;
// };
export interface CalculateOptions extends FloatOptions {};
export async function init() {
const binding: Awaited<ReturnType<typeof getGMPInterface>> = await getGMPInterface();
export async function init(): Promise<GMPLib> {
const binding: GMPFunctions = await getGMPInterface();

@@ -48,0 +48,0 @@ const createContext = (options: CalculateOptions) => {

87

test/Float.test.ts

@@ -1,2 +0,2 @@

import { CalculateType, init as initGMP } from '../src';
import { CalculateTypeWithDestroy, FloatRoundingMode, init as initGMP } from '../src';
/* global test, expect */

@@ -6,3 +6,3 @@

let gmp: Awaited<ReturnType<typeof initGMP>> = null;
let ctx: CalculateType = null;
let ctx: CalculateTypeWithDestroy = null;

@@ -14,2 +14,6 @@ beforeAll(async () => {

afterAll(() => {
ctx.destroy();
});
const compare = (int: ReturnType<typeof ctx.Float>, res: string) => {

@@ -22,2 +26,3 @@ expect(int.toString()).toBe(res);

compare(ctx.Float('0'), '0');
compare(ctx.Float('-0'), '-0');
compare(ctx.Float('-1'), '-1');

@@ -34,5 +39,9 @@ compare(ctx.Float('0.5'), '0.5');

compare(ctx.Float(0), '0');
compare(ctx.Float(-0), '-0');
compare(ctx.Float(1), '1');
compare(ctx.Float(0.5), '0.5');
compare(ctx.Float(-0.5), '-0.5');
compare(ctx.Float(Infinity), '@Inf@');
compare(ctx.Float(-Infinity), '-@Inf@');
compare(ctx.Float(NaN), '@NaN@');
});

@@ -49,2 +58,7 @@

test('construct from other types', () => {
compare(ctx.Float(ctx.Integer('123')), '123');
compare(ctx.Float(ctx.Rational(1, 2)), '0.5');
});
test('Constants', () => {

@@ -63,2 +77,4 @@ compare(ctx.Pi(), '3.1416');

compare(ctx.Float(0.4).add(ctx.Float(0.6)), '1');
compare(ctx.Float(0.4).add(ctx.Integer(2)), '2.40002');
compare(ctx.Float(0.4).add(ctx.Rational(1, 2)), '0.899994');
});

@@ -71,2 +87,4 @@

compare(ctx.Float(0.6).sub(ctx.Float(0.4)), '0.200005');
compare(ctx.Float(0.4).sub(ctx.Integer(2)), '-1.60001');
compare(ctx.Float(0.4).sub(ctx.Rational(1, 2)), '-0.0999985');
});

@@ -79,2 +97,4 @@

compare(ctx.Float(6).mul(ctx.Float(2)), '12');
compare(ctx.Float(0.4).mul(ctx.Integer(2)), '0.800003');
compare(ctx.Float(0.4).mul(ctx.Rational(1, 2)), '0.200001');
});

@@ -87,2 +107,4 @@

compare(ctx.Float(7).div(ctx.Float(2)), '3.5');
compare(ctx.Float(6).div(ctx.Integer(2)), '3');
compare(ctx.Float(6).div(ctx.Rational(4, 2)), '3');
});

@@ -125,2 +147,9 @@

test('isInteger()', () => {
expect(ctx.Float(-1).isInteger()).toBe(true);
expect(ctx.Float(0).isInteger()).toBe(true);
expect(ctx.Float(0.01).isInteger()).toBe(false);
expect(ctx.Float(1).isInteger()).toBe(true);
});
test('isZero()', () => {

@@ -161,2 +190,6 @@ expect(ctx.Float(0).isZero()).toBe(true);

expect(ctx.Float(1).isEqual(ctx.Float(0))).toBe(false);
expect(ctx.Float(1).isEqual(ctx.Integer(1))).toBe(true);
expect(ctx.Float(1).isEqual(ctx.Integer(0))).toBe(false);
expect(ctx.Float(1).isEqual(ctx.Rational(1, 1))).toBe(true);
expect(ctx.Float(1).isEqual(ctx.Rational(1, 2))).toBe(false);
});

@@ -304,2 +337,7 @@

test('sign()', () => {
expect(ctx.Float(0.1).sign()).toBe(1);
expect(ctx.Float(-0.1).sign()).toBe(-1);
});
test('ceil()', () => {

@@ -333,3 +371,13 @@ compare(ctx.Float(0.1).ceil(), '1');

test('exponent2()', () => {
expect(ctx.Float(1).exponent2()).toBe(1);
expect(ctx.Float(0b1000).exponent2()).toBe(4);
expect(ctx.Float(0.375).exponent2()).toBe(-1); // 0.011
expect(ctx.Float(0.1875).exponent2()).toBe(-2); // 0.0011
});
test('special values', () => {
compare(ctx.Float(), '@NaN@');
compare(ctx.Float(null), '@NaN@');
compare(ctx.Float(undefined), '@NaN@');
compare(ctx.Float(0), '0');

@@ -351,1 +399,36 @@ compare(ctx.Float(-0), '-0');

});
test('FloatOptions', () => {
const roundingMode = FloatRoundingMode.ROUND_TOWARD_NEG_INF;
const options = { precisionBits: 10, roundingMode };
expect(gmp.calculate(g => g.Float(1).div(3), {})).toBe('0.33333333333333337');
expect(gmp.calculate(g => g.Float(1, {}).div(3))).toBe('0.33333333333333337');
expect(gmp.calculate(g => g.Float(1).div(3), options)).toBe('0.333');
expect(gmp.calculate(g => g.Float(1, options).div(3))).toBe('0.333');
expect(gmp.calculate(g => g.Float(1, options).div(3), {})).toBe('0.333');
// merge precision
expect(gmp.calculate(g => g.Float(1).div(g.Float(3)), options)).toBe('0.333');
expect(gmp.calculate(g => g.Float(1, { precisionBits: 5 }).div(g.Float(3, { precisionBits: 15 })), options)).toBe('0.333328');
expect(gmp.calculate(g => g.Float(1, { precisionBits: 15 }).div(g.Float(3, { precisionBits: 5 })), options)).toBe('0.333328');
expect(gmp.calculate(g => g.Float(1, { precisionBits: 4 }).div(g.Float(3, { precisionBits: 5 })), options)).toBe('0.328');
// merge roundingMode
expect(gmp.calculate(g => g.Float(1).div(g.Float(3)), options)).toBe('0.333');
const { ROUND_TOWARD_INF } = FloatRoundingMode;
expect(gmp.calculate(g => g.Float(1, { roundingMode: ROUND_TOWARD_INF }).div(g.Float(3)), options)).toBe('0.33349');
expect(gmp.calculate(g => g.Float(1).div(g.Float(3, { roundingMode: ROUND_TOWARD_INF })), options)).toBe('0.33301');
});
test('FloatOptions constants', () => {
const roundingMode = FloatRoundingMode.ROUND_TOWARD_NEG_INF;
const options = { precisionBits: 10, roundingMode };
expect(gmp.calculate(g => g.Pi(), options)).toBe('3.1406');
expect(gmp.calculate(g => g.Pi(options))).toBe('3.1406');
expect(gmp.calculate(g => g.Catalan(), options)).toBe('0.91503');
expect(gmp.calculate(g => g.Catalan(options))).toBe('0.91503');
expect(gmp.calculate(g => g.EulerConstant(), options)).toBe('0.57714');
expect(gmp.calculate(g => g.EulerConstant(options))).toBe('0.57714');
expect(gmp.calculate(g => g.EulerNumber(), options)).toBe('2.7148');
expect(gmp.calculate(g => g.EulerNumber(options))).toBe('2.7148');
expect(gmp.calculate(g => g.Log2(), options)).toBe('0.69238');
expect(gmp.calculate(g => g.Log2(options))).toBe('0.69238');
});

8

test/Integer.test.ts
import { DivMode } from '../src/integer';
import { CalculateType, FloatType, init as initGMP, IntegerType, RationalType } from '../src';
import { CalculateTypeWithDestroy, FloatType, init as initGMP, IntegerType, RationalType } from '../src';
/* global test, expect */

@@ -7,3 +7,3 @@

let gmp: Awaited<ReturnType<typeof initGMP>> = null;
let ctx: CalculateType = null;
let ctx: CalculateTypeWithDestroy = null;

@@ -15,2 +15,6 @@ beforeAll(async () => {

afterAll(() => {
ctx.destroy();
});
const compare = (int: IntegerType | RationalType | FloatType, res: string) => {

@@ -17,0 +21,0 @@ expect(int.toString()).toBe(res);

8

test/Rational.test.ts

@@ -1,2 +0,2 @@

import { CalculateType, init as initGMP, IntegerType, RationalType } from '../src';
import { CalculateTypeWithDestroy, init as initGMP, IntegerType, RationalType } from '../src';
/* global test, expect */

@@ -6,3 +6,3 @@

let gmp: Awaited<ReturnType<typeof initGMP>> = null;
let ctx: CalculateType = null;
let ctx: CalculateTypeWithDestroy = null;

@@ -14,2 +14,6 @@ beforeAll(async () => {

afterAll(() => {
ctx.destroy();
});
const compare = (int: RationalType | IntegerType, res: string) => {

@@ -16,0 +20,0 @@ expect(int.toString()).toBe(res);

.github/workflows/build.yml

Sorry, the diff of this file is not supported yet

dist/index.esm.js

Sorry, the diff of this file is too big to display

dist/index.esm.min.js

Sorry, the diff of this file is too big to display

dist/index.umd.js

Sorry, the diff of this file is too big to display

dist/index.umd.min.js

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc