Initialize state with a default algorithm.
Initialize state with a linear congruential algorithm X = (aX + c) mod 2^m2exp.
Initialize state for a linear congruential algorithm as per gmp_randinit_lc_2exp.
Initialize state for a Mersenne Twister algorithm.
Initialize rop with a copy of the algorithm and state from op.
Set an initial seed value into state.
Set an initial seed value into state.
Generate a uniformly distributed random number of n bits, i.e. in the range 0 to 2^n - 1 inclusive.
Generate a uniformly distributed random number in the range 0 to n - 1, inclusive.
Get GMP limb size
Set rop to the absolute value of op rounded in the direction rnd.
Set rop to the arc-cosine of op rounded in the direction rnd.
Set rop to the inverse hyperbolic cosine of op rounded in the direction rnd.
Set rop to op1 + op2 rounded in the direction rnd.
Set rop to op1 + op2 rounded in the direction rnd.
Set rop to op1 + op2 rounded in the direction rnd.
Set rop to op1 + op2 rounded in the direction rnd.
Set rop to op1 + op2 rounded in the direction rnd.
Set rop to op1 + op2 rounded in the direction rnd.
Set rop to the arithmetic-geometric mean of op1 and op2 rounded in the direction rnd.
Set rop to the value of the Airy function Ai on x rounded in the direction rnd.
Set rop to the arc-sine of op rounded in the direction rnd.
Set rop to the inverse hyperbolic sine of op rounded in the direction rnd.
Set rop to the arc-tangent of op rounded in the direction rnd.
Set rop to the arc-tangent2 of y and x rounded in the direction rnd.
Set rop to the inverse hyperbolic tangent of op rounded in the direction rnd.
Set rop to the value of the Beta function at arguments op1 and op2, rounded in the direction rnd.
Return non-zero value if one is able to round correctly x to precision prec with the direction rnd2, and 0 otherwise.
Set rop to the cubic root of op rounded in the direction rnd.
Set rop to op rounded to the next higher or equal representable integer (like mpfr_rint(mpfr_t, mpfr_t, mpfr_rnd_t) with MPFR_RNDU).
Check that x is within the current range of acceptable values.
Free the space occupied by the significand of x.
Clear (lower) the divide-by-zero flag.
Clear (lower) the erange flag.
Clear (lower) all global flags (underflow, overflow, divide-by-zero, invalid, inexact, erange).
Clear (lower) the inexact flag.
Clear (lower) the invalid flag.
Clear (lower) the overflow flag.
Clear (lower) the underflow flag.
Free the space occupied by all the mpfr_t variables of the given list x.
Compare op1 and op2.
Compare op1 and op2.
Compare op1 and op2.
Compare op1 and op2.
Compare op1 and op2 * 2^e.
Compare op1 and op2.
Compare op1 and op2 * 2^e.
Compare op1 and op2.
Compare |op1| and |op2|.
Compare |op1| and |op2|.
Set rop to the value of Catalan’s constant 0.915… rounded in the direction rnd.
Set rop to the value of Euler’s constant 0.577… rounded in the direction rnd.
Set rop to the logarithm of 2 rounded in the direction rnd.
Set rop to the value of Pi rounded in the direction rnd.
Set the value of rop from op1, rounded toward the given direction rnd, then set its sign bit to that of op2 (even when op1 or op2 is a NaN).
Set rop to the cosine of op rounded in the direction rnd.
Set rop to the hyperbolic cosine of op rounded in the direction rnd.
Set rop to the cotangent of op rounded in the direction rnd.
Set rop to the hyperbolic cotangent of op rounded in the direction rnd.
Set rop to the cosecant of op rounded in the direction rnd.
Set rop to the hyperbolic cosecant of op rounded in the direction rnd.
Set rop to op1 / op2 rounded in the direction rnd.
Set rop to op1 - op2 rounded in the direction rnd.
Set rop to the value of the Digamma (sometimes also called Psi) function on op rounded in the direction rnd.
Set rop to the positive difference of op1 and op2, i.e., op1 - op2 rounded in the direction rnd if op1 > op2, +0 if op1 ≤ op2, and NaN if op1 or op2 is NaN.
Set rop to op1 / op2 rounded in the direction rnd.
Set rop to op1 divided by 2^op2 rounded in the direction rnd.
Set rop to op1 divided by 2^op2 rounded in the direction rnd.
Set rop to op1 divided by 2^op2 rounded in the direction rnd.
Set rop to op1 / op2 rounded in the direction rnd.
Set rop to op1 / op2 rounded in the direction rnd.
Set rop to op1 / op2 rounded in the direction rnd.
Set rop to op1 / op2 rounded in the direction rnd.
Set rop to op1 / op2 rounded in the direction rnd.
Return the divide-by-zero flag, which is non-zero iff the flag is set.
Set rop to the dot product of elements of a by those of b, whose common size is n, correctly rounded in the direction rnd.
Set rop to the exponential integral of op rounded in the direction rnd.
Return non-zero if op1 and op2 are both non-zero ordinary numbers with the same exponent and the same first op3 bits.
Return non-zero if op1 = op2, and zero otherwise.
Generate one random float according to an exponential distribution, with mean one.
Return the erange flag, which is non-zero iff the flag is set.
Set rop to the value of the error function on op rounded in the direction rnd.
Set rop to the value of the complementary error function on op rounded in the direction rnd.
Set rop to the exponential of op rounded in the direction rnd.
Set rop to 10^op rounded in the direction rnd.
Set rop to 2^op rounded in the direction rnd.
Set rop to the e^op - 1, rounded in the direction rnd.
Set rop to the factorial of op rounded in the direction rnd.
Return non-zero if op would fit in the C data type (32-bit) long when rounded to an integer in the direction rnd.
Return non-zero if op would fit in the C data type (32-bit) int when rounded to an integer in the direction rnd.
Return non-zero if op would fit in the C data type (32-bit) long when rounded to an integer in the direction rnd.
Return non-zero if op would fit in the C data type (16-bit) short when rounded to an integer in the direction rnd.
Return non-zero if op would fit in the C data type (32-bit) unsigned int when rounded to an integer in the direction rnd.
Return non-zero if op would fit in the C data type (32-bit) unsigned long when rounded to an integer in the direction rnd.
Return non-zero if op would fit in the C data type (32-bit) unsigned long when rounded to an integer in the direction rnd.
Return non-zero if op would fit in the C data type (16-bit) unsigned short when rounded to an integer in the direction rnd.
Clear (lower) the group of flags specified by mask.
Restore the flags specified by mask to their state represented in flags.
Return all the flags.
Set (raise) the group of flags specified by mask.
Return the flags specified by mask.
Set rop to op rounded to the next lower or equal representable integer.
Set rop to (op1 * op2) + op3 rounded in the direction rnd.
Set rop to (op1 * op2) + (op3 * op4) rounded in the direction rnd.
Set rop to (op1 * op2) - (op3 * op4) rounded in the direction rnd.
Set r to the value of x - n * y, rounded according to the direction rnd, where n is the integer quotient of x divided by y, rounded toward zero.
Set r to the value of x - n * y, rounded according to the direction rnd, where n is the integer quotient of x divided by y, rounded toward zero.
Set rop to (op1 * op2) - op3 rounded in the direction rnd.
Set rop to the fractional part of op, having the same sign as op, rounded in the direction rnd.
Free all caches and pools used by MPFR internally.
Free various caches and pools used by MPFR internally, as specified by way, which is a set of flags
Free the pools used by MPFR internally.
Free a string allocated by mpfr_get_str using the unallocation function (see GNU MPFR - Memory Handling).
Set exp and y such that 0.5 ≤ abs(y) < 1 and y * 2^exp = x rounded to the precision of y, using the given rounding mode.
Set rop to the value of the Gamma function on op rounded in the direction rnd.
Set rop to the value of the incomplete Gamma function on op and op2, rounded in the direction rnd.
Convert op to a double, using the rounding mode rnd.
Return d and set exp such that 0.5 ≤ abs(d) <1 and d * 2^exp = op rounded to double precision, using the given rounding mode.
Return the current default MPFR precision in bits.
Get the default rounding mode.
Return the (current) largest exponent allowed for a floating-point variable.
Return the maximum exponent allowed for mpfr_set_emax.
Return the minimum exponent allowed for mpfr_set_emax.
Return the (current) smallest exponent allowed for a floating-point variable.
Return the maximum exponent allowed for mpfr_set_emin.
Return the minimum exponent allowed for mpfr_set_emin.
Return the exponent of x, assuming that x is a non-zero ordinary number and the significand is considered in [1/2,1).
Return the precision of x, i.e., the number of bits used to store its significand.
Convert op to a mpq_t.
Convert op to a long after rounding it with respect to rnd.
Convert op to a string of digits in base b, with rounding in the direction rnd, where n is either zero (see below) or the number of significant digits output in the string; in the latter case, n must be greater or equal to 2.
Return the minimal integer m such that any number of p bits, when output with m digits in radix b with rounding to nearest, can be recovered exactly when read again, still with rounding to nearest. More precisely, we have m = 1 + ceil(p*log(2)/log(b)), with p replaced by p-1 if b is a power of 2.
Convert op to an unsigned long after rounding it with respect to rnd.
Return the MPFR version, as a null-terminated string.
Convert op to a mpz_t, after rounding it with respect to rnd.
Put the scaled significand of op (regarded as an integer, with the precision of op) into rop, and return the exponent exp (which may be outside the current exponent range) such that op = rop * 2^exp.
Return non-zero if op1 > op2, and zero otherwise.
Return non-zero if op1 ≥ op2, and zero otherwise.
Set rop to the Euclidean norm of x and y, i.e., the square root of the sum of the squares of x and y rounded in the direction rnd.
Return the inexact flag, which is non-zero iff the flag is set.
Return non-zero if op is an infinity. Return zero otherwise.
Initialize x, set its precision to the default precision, and set its value to NaN.
Initialize x, set its precision to be exactly prec bits and its value to NaN.
Initialize rop and set its value from op, rounded in the direction rnd.
Initialize rop and set its value from op, rounded in the direction rnd.
Initialize rop and set its value from op, rounded in the direction rnd.
Initialize rop and set its value from op, rounded in the direction rnd.
Initialize x and set its value from the string s in base base, rounded in the direction rnd.
Initialize rop and set its value from op, rounded in the direction rnd.
Initialize rop and set its value from op, rounded in the direction rnd.
Initialize all the mpfr_t variables of the given list x, set their precision to the default precision and their value to NaN.
Initialize all the mpfr_t variables of the given variable argument x, set their precision to be exactly prec bits and their value to NaN.
Return non-zero iff op is an integer.
Set rop to the value of the first kind Bessel function of order 0 on op rounded in the direction rnd.
Set rop to the value of the first kind Bessel function of order 1 on op rounded in the direction rnd.
Set rop to the value of the first kind Bessel function of order n on op rounded in the direction rnd.
Return non-zero if op1 < op2, and zero otherwise.
Return non-zero if op1 ≤ op2, and zero otherwise.
Return non-zero if op1 < op2 or op1 > op2 (i.e., neither op1, nor op2 is NaN, and op1 ≠op2), zero otherwise (i.e., op1 and/or op2 is NaN, or op1 = op2).
Set rop to the value of the logarithm of the absolute value of the Gamma function on op rounded in the direction rnd.
Set rop to real part of the dilogarithm of op rounded in the direction rnd.
Set rop to the value of the logarithm of the Gamma function on op rounded in the direction rnd.
Set rop to the natural logarithm of op rounded in the direction rnd.
Set rop to log10(op) rounded in the direction rnd.
Set rop to the logarithm of one plus op, rounded in the direction rnd.
Set rop to log2(op) rounded in the direction rnd.
Set rop to the natural logarithm of op rounded in the direction rnd.
Set rop to the maximum of op1 and op2.
Set rop to the minimum of op1 and op2.
Return the minimal number of bits required to store the significand of x, and 0 for special values, including 0.
Set simultaneously iop to the integral part of op and fop to the fractional part of op, rounded in the direction rnd with the corresponding precision of iop and fop.
Set rop to op1 * op2 rounded in the direction rnd.
Set rop to op1 * 2^op2 rounded in the direction rnd.
Set rop to op1 * 2^op2 rounded in the direction rnd.
Set rop to op1 * 2^op2 rounded in the direction rnd.
Set rop to op1 * op2 rounded in the direction rnd.
Set rop to op1 * op2 rounded in the direction rnd.
Set rop to op1 * op2 rounded in the direction rnd.
Set rop to op1 * op2 rounded in the direction rnd.
Set rop to op1 * op2 rounded in the direction rnd.
Return non-zero if op is NaN. Return zero otherwise.
Return the invalid flag, which is non-zero iff the flag is set.
Set rop to -op rounded in the direction rnd.
Equivalent to mpfr_nexttoward where y is plus infinity.
Equivalent to mpfr_nexttoward where y is minus infinity.
Replace x by the next floating-point number in the direction of y.
Generate one random float according to a standard normal gaussian distribution (with mean zero and variance one).
Return non-zero if op is an ordinary number (i.e., neither NaN nor an infinity). Return zero otherwise.
Return the overflow flag, which is non-zero iff the flag is set.
Set rop to op1 raised to op2, rounded in the direction rnd.
Set rop to op1 raised to op2, rounded in the direction rnd.
Set rop to op1 raised to op2, rounded in the direction rnd.
Set rop to op1 raised to op2, rounded in the direction rnd.
Round x according to rnd with precision prec, which must be an integer between MPFR_PREC_MIN and MPFR_PREC_MAX (otherwise the behavior is undefined).
Set rop to the reciprocal square root of op rounded in the direction rnd.
Return non-zero if op is a regular number (i.e., neither NaN, nor an infinity nor zero). Return zero otherwise.
Compute the relative difference between op1 and op2 and store the result in rop.
Set r to the value of x - n * y, rounded according to the direction rnd, where n is the integer quotient of x divided by y, rounded to the nearest integer (ties rounded to even).
Set r to the value of x - n * y, rounded according to the direction rnd, where n is the integer quotient of x divided by y, rounded to the nearest integer (ties rounded to even).
Set rop to op rounded to the nearest representable integer in the given direction rnd.
Set rop to op rounded to the next higher or equal integer.
Set rop to op rounded to the next lower or equal integer.
Set rop to op rounded to the nearest integer, rounding halfway cases away from zero.
Set rop to op rounded to the nearest integer, rounding halfway cases to the nearest even integer.
Set rop to op rounded to the next integer toward zero.
Set rop to the kth root of op rounded in the direction rnd.
Set rop to op rounded to the nearest representable integer, rounding halfway cases away from zero (as in the roundTiesToAway mode of IEEE 754-2008).
Set rop to op rounded to the nearest representable integer, rounding halfway cases with the even-rounding rule zero (like mpfr_rint(mpfr_t, mpfr_t, mpfr_rnd_t) with MPFR_RNDN).
Set rop to the secant of op rounded in the direction rnd.
Set rop to the hyperbolic secant of op rounded in the direction rnd.
Set the value of rop from op rounded toward the given direction rnd.
Set the value of rop from op rounded toward the given direction rnd.
Set the default precision to be exactly prec bits, where prec can be any integer between MPFR_PREC_MINand MPFR_PREC_MAX.
Set the default rounding mode to rnd.
Set (raised) the divide-by-zero flag.
Set the largest exponent allowed for a floating-point variable.
Set the smallest exponent allowed for a floating-point variable.
Set (raised) the erange flag.
Set the exponent of x if e is in the current exponent range.
Set (raised) the inexact flag.
Set the variable x to NaN (Not-a-Number).
Set (raised) the invalid flag.
Set (raised) the overflow flag.
Reset the precision of x to be exactly prec bits, and set its value to NaN.
Reset the precision of x to be exactly prec bits.
Set the value of rop from op rounded toward the given direction rnd.
Set the value of rop from op rounded toward the given direction rnd.
Set the value of rop from op multiplied by two to the power e, rounded toward the given direction rnd.
Set rop to the value of the string s in base base, rounded in the direction rnd.
Set the value of rop from op rounded toward the given direction rnd.
Set the value of rop from op multiplied by two to the power e, rounded toward the given direction rnd.
Set (raised) the underflow flag.
Set the value of rop from op rounded toward the given direction rnd.
Set the value of rop from op multiplied by two to the power e, rounded toward the given direction rnd.
Set the value of rop from op, rounded toward the given direction rnd, then set (resp. clear) its sign bit if s is non-zero (resp. zero), even when op is a NaN.
Return a positive value if op > 0, zero if op = 0, and a negative value if op < 0.
Set rop to op1 / op2 rounded in the direction rnd.
Set rop to op1 - op2 rounded in the direction rnd.
Return a non-zero value iff op has its sign bit set (i.e., if it is negative, -0, or a NaN whose representation has its sign bit set).
Set rop to the sine of op rounded in the direction rnd.
Set simultaneously sop to the sine of op and cop to the cosine of op, rounded in the direction rnd with the corresponding precisions of sop and cop, which must be different variables.
Set rop to the hyperbolic sine of op rounded in the direction rnd.
Set simultaneously sop to the hyperbolic sine of op and cop to the hyperbolic cosine of op, rounded in the direction rnd with the corresponding precision of sop and cop, which must be different variables.
Set rop to the square of op rounded in the direction rnd.
Set rop to the square root of op rounded in the direction rnd.
Set rop to the square root of op rounded in the direction rnd.
Read a floating-point number from a string nptr in base base, rounded in the direction rnd.
Set rop to op1 - op2 rounded in the direction rnd.
Set rop to op1 - op2 rounded in the direction rnd.
Set rop to op1 - op2 rounded in the direction rnd.
Set rop to op1 - op2 rounded in the direction rnd.
Set rop to op1 - op2 rounded in the direction rnd.
Set rop to op1 - op2 rounded in the direction rnd.
This function rounds x emulating subnormal number arithmetic.
Set rop to the sum of all elements of tab, whose size is n, correctly rounded in the direction rnd.
Allocates memory for the mpfr_t C struct and returns pointer
Deallocates memory of a mpfr_t C struct
Deallocates memory of a NULL-terminated list of mpfr_t variables
Set rop to the tangent of op rounded in the direction rnd.
Set rop to the hyperbolic tangent of op rounded in the direction rnd.
This function implements the totalOrder predicate from IEEE 754-2008, where -NaN < -Inf < negative finite numbers < -0 < +0 < positive finite numbers < +Inf < +NaN. It returns a non-zero value (true) when x is smaller than or equal to y for this order relation, and zero (false) otherwise
Set rop to op rounded to the next representable integer toward zero (like mpfr_rint(mpfr_t, mpfr_t, mpfr_rnd_t) with MPFR_RNDZ).
Set rop to op1 / op2 rounded in the direction rnd.
Set rop to op1 raised to op2, rounded in the direction rnd.
Set rop to op1 raised to op2, rounded in the direction rnd.
Set rop to op1 - op2 rounded in the direction rnd.
Return the underflow flag, which is non-zero iff the flag is set.
Return non-zero if op1 or op2 is a NaN (i.e., they cannot be compared), zero otherwise.
Generate a uniformly distributed random float.
Generate a uniformly distributed random float in the interval 0 ≤ rop < 1.
Set rop to the value of the first kind Bessel function of order 0 on op rounded in the direction rnd.
Set rop to the value of the first kind Bessel function of order 1 on op rounded in the direction rnd.
Set rop to the value of the first kind Bessel function of order n on op rounded in the direction rnd.
Set rop to op1 - op2 rounded in the direction rnd.
Return non-zero if op is zero. Return zero otherwise.
Set rop to the value of the Riemann Zeta function on op rounded in the direction rnd.
Set rop to the value of the Riemann Zeta function on op rounded in the direction rnd.
Set rop to the absolute value of op.
Set sum to addend1 + addend2.
Remove any factors that are common to the numerator and denominator of op, and make the denominator positive.
Free the space occupied by x.
Free the space occupied by a NULL-terminated list of mpq_t variables.
Compare op1 and op2.
Compare op1 and num2 / den2.
Compare op1 and num2 / den2.
Compare op1 and op2.
Set quotient to dividend / divisor.
Set rop to op1 / 2^op2.
Return non-zero if op1 and op2 are equal, zero if they are non-equal.
Convert op to a double, truncating if necessary (i.e. rounding towards zero).
Set denominator to the denominator of rational.
Set numerator to the numerator of rational.
Convert op to a string of digits in base base.
Initialize x and set it to 0/1.
Initialize a NULL-terminated list of mpq_t variables, and set their values to 0/1.
Set inverted_number to 1 / number.
Set product to multiplier * multiplicand.
Set rop to op1 * 2*op2.
Set negated_operand to -operand.
Assign rop from op.
Set the denominator of rational to denominator.
Set the numerator of rational to numerator.
Set the value of rop to op1 / op2.
Set the value of rop to op1 / op2.
Assign rop from op.
Set difference to minuend - subtrahend.
Allocates memory for the mpq_t C struct and returns pointer
Deallocates memory of a mpq_t C struct
Deallocates memory of a NULL-terminated list of mpq_t variables
Set rop to the double-factorial n!!.
Set rop to the absolute value of op.
Set rop to op1 + op2.
Set rop to op1 + op2.
Set rop to rop + op1 * op2.
Set rop to rop + op1 * op2.
Set rop to op1 bitwise-and op2.
Compute the binomial coefficient n over k and store the result in rop.
Compute the binomial coefficient n over k and store the result in rop.
Set the quotient q to ceiling(n / d).
Set the quotient q to ceiling(n / 2^b).
Set the quotient q to ceiling(n / d), and return the remainder r = | n - q * d |.
Set the quotient q to ceiling(n / d), and set the remainder r to n - q * d.
Set quotient q to ceiling(n / d), set the remainder r to n - q * d, and return | r |.
Set the remainder r to n - q * d where q = ceiling(n / d).
Set the remainder r to n - q * 2^b where q = ceiling(n / 2^b).
Set the remainder r to n - q * d where q = ceiling(n / d), and return | r |.
Return the remainder | r | where r = n - q * d, and where q = ceiling(n / d).
Free the space occupied by x.
Free the space occupied by a NULL-terminated list of mpz_t variables.
Clear bit bit_index in rop.
Compare op1 and op2.
Compare op1 and op2.
Compare op1 and op2.
Compare op1 and op2.
Compare the absolute values of op1 and op2.
Compare the absolute values of op1 and op2.
Compare the absolute values of op1 and op2.
Set rop to the one’s complement of op.
Complement bit bitIndex in rop.
Return non-zero if n is congruent to c modulo 2^b.
Return non-zero if n is congruent to c modulo d.
Return non-zero if n is congruent to c modulo d.
Set q to n / d when it is known in advance that d divides n.
Set q to n / d when it is known in advance that d divides n.
Return non-zero if n is exactly divisible by 2^b.
Return non-zero if n is exactly divisible by d.
Return non-zero if n is exactly divisible by d.
Determine whether op is even.
Fill rop with word data from op.
Set rop to the factorial n!.
Set the quotient q to floor(n / d).
Set the quotient q to floor(n / 2^b).
Set the quotient q to floor(n / d), and return the remainder r = | n - q * d |.
Set the quotient q to floor(n / d), and set the remainder r to n - q * d.
Set quotient q to floor(n / d), set the remainder r to n - q * d, and return | r |.
Set the remainder r to n - q * d where q = floor(n / d).
Set the remainder r to n - q * 2^b where q = floor(n / 2^b).
Set the remainder r to n - q * d where q = floor(n / d), and return | r |.
Return the remainder | r | where r = n - q * d, and where q = floor(n / d).
Sets fn to F[n], and fnsub1 to F[n - 1].
Sets fn to to F[n], the n’th Fibonacci number.
Return non-zero iff the value of op fits in a signed 32-bit integer. Otherwise, return zero.
Return non-zero iff the value of op fits in a signed 32-bit integer. Otherwise, return zero.
Return non-zero iff the value of op fits in a signed 16-bit integer. Otherwise, return zero.
Return non-zero iff the value of op fits in an unsigned 32-bit integer. Otherwise, return zero.
Return non-zero iff the value of op fits in an unsigned 32-bit integer. Otherwise, return zero.
Return non-zero iff the value of op fits in an unsigned 16-bit integer. Otherwise, return zero.
Set rop to the greatest common divisor of op1 and op2.
Compute the greatest common divisor of op1 and op2. If rop is not null, store the result there.
Set g to the greatest common divisor of a and b, and in addition set s and t to coefficients satisfying a * s + b * t = g.
Convert op to a double, truncating if necessary (i.e. rounding towards zero).
Convert op to a double, truncating if necessary (i.e. rounding towards zero), and returning the exponent separately.
Return the value of op as an signed long.
Convert op to a string of digits in base base.
Return the value of op as an unsigned long.
Return limb number n from op.
Return the hamming distance between the two operands.
Initialize x, and set its value to 0.
Initialize x, with space for n-bit numbers, and set its value to 0.
Initialize rop with limb space and set the initial numeric value from op.
Initialize rop with limb space and set the initial numeric value from op.
Initialize rop with limb space and set the initial numeric value from op.
Initialize a NULL-terminated list of mpz_t variables, and set their values to 0.
Compute the inverse of op1 modulo op2 and put the result in rop.
Set rop to op1 bitwise inclusive-or op2.
Calculate the Jacobi symbol (a/b).
Calculate the Jacobi symbol (a/b) with the Kronecker extension (a/2) = (2/a) when a odd, or (a/2) = 0 when a even.
Calculate the Jacobi symbol (a/b) with the Kronecker extension (a/2) = (2/a) when a odd, or (a/2) = 0 when a even.
Calculate the Jacobi symbol (a/b) with the Kronecker extension (a/2) = (2/a) when a odd, or (a/2) = 0 when a even.
Set rop to the least common multiple of op1 and op2.
Set rop to the least common multiple of op1 and op2.
Calculate the Legendre symbol (a/p).
Return a pointer to the limb array representing the absolute value of x.
Sets ln to L[n], and lnsub1 to L[n - 1].
Sets ln to to L[n], the n’th Lucas number.
Set rop to the m-multi-factorial n!^(m)n.
An implementation of the probabilistic primality test found in Knuth's Seminumerical Algorithms book.
Set r to n mod d.
Set r to n mod d.
Set rop to op1 * op2.
Set rop to op1 * 2^op2.
Set rop to op1 * op2.
Set rop to op1 * op2.
Set rop to -op.
Set rop to the next prime greater than op.
Determine whether op is odd.
Return non-zero if op is a perfect power, i.e., if there exist integers a and b, with b > 1, such that op = a^b.
Return non-zero if op is a perfect square, i.e., if the square root of op is an integer.
Return the population count of op.
Set rop to base^exp. The case 0^0 yields 1.
Set rop to (base^exp) modulo mod.
Set rop to (base^exp) modulo mod.
Set rop to (base^exp) modulo mod.
Set rop to the primorial of n, i.e. the product of all positive prime numbers ≤ n.
Determine whether n is prime.
Change the space allocated for x to n bits.
Remove all occurrences of the factor f from op and store the result in rop.
Special initialization of x, using the given limb array and size.
Set rop to the truncated integer part of the nth root of op.
Set root to the truncated integer part of the nth root of u. Set rem to the remainder, u - root^n.
Generate a random integer with long strings of zeros and ones in the binary representation.
Scan op for 0 bit.
Scan op for 1 bit.
Set the value of rop from op.
Set the value of rop from op.
Set the value of rop from op.
Set the value of rop from op.
Set bit bitIndex in rop.
Calculate the Jacobi symbol (a/b) with the Kronecker extension (a/2) = (2/a) when a odd, or (a/2) = 0 when a even.
Return the size of op measured in number of limbs.
Return the size of op measured in number of digits in the given base.
Set rop to the truncated integer part of the square root of op.
Set rop1 to the truncated integer part of the square root of op, like mpz_sqrt. Set rop2 to the remainder op - rop1 * rop1, which will be zero if op is a perfect square.
Set rop to op1 - op2.
Set rop to op1 - op2.
Set rop to rop - op1 * op2.
Set rop to rop - op1 * op2.
Allocates memory for the mpfr_t C struct and returns pointer
Deallocates memory of a mpfr_t C struct
Deallocates memory of a NULL-terminated list of mpfr_t variables
Set the quotient q to trunc(n / d).
Set the quotient q to trunc(n / 2^b).
Set the quotient q to trunc(n / d), and return the remainder r = | n - q * d |.
Set the quotient q to trunc(n / d), and set the remainder r to n - q * d.
Set quotient q to trunc(n / d), set the remainder r to n - q * d, and return | r |.
Set the remainder r to n - q * d where q = trunc(n / d).
Set the remainder r to n - q * 2^b where q = trunc(n / 2^b).
Set the remainder r to n - q * d where q = trunc(n / d), and return | r |.
Return the remainder | r | where r = n - q * d, and where q = trunc(n / d).
Test bit bitIndex in op and return 0 or 1 accordingly.
Calculate the Jacobi symbol (a/b) with the Kronecker extension (a/2) = (2/a) when a odd, or (a/2) = 0 when a even.
Set rop to base^exp. The case 0^0 yields 1.
Set rop to op1 - op2.
Generate a uniformly distributed random integer in the range 0 to 2^n - 1, inclusive.
Generate a uniform random integer in the range 0 to n - 1, inclusive.
Set rop to op1 bitwise exclusive-or op2.
Initializes new MPFR float from JS string
Converts JS string into MPFR float
Converts MPFR float into JS string
Converts JS string into MPQ rational
Converts MPQ rational into JS string
Initializes new MPFR float from JS string
Converts JS string into MPZ integer
Converts MPZ int into JS string
Generated using TypeDoc
Free all memory occupied by state.