Module Mlmpfr

Raised if precision is not included in [Mlmpfr.mpfr_prec_min; Mlmpfr.mpfr_prec_max].

Raised if base is not included in [2;64], or 0 (automatic base detection).

Raised if mlmpfr fails to perfom some internal mpfr_t copies.

Raised if mlmpfr tries to call a mpfr_*_ui function with a negative integer.

Binding to C MPFR mpfr_t type.

Associated to an mpfr_t value, a ternary value indicates if it was correctly rounded.

Rounding modes.

Flags as described here.

Minimum allowed precision.

Maximum allowed precision.

Mlmpfr.set_default_prec p modifies the default precision to be exactly p bits. The precision of a variable means the number of bits used to store its significand. All subsequent calls to any functions will use this precision by default, but previously initialized variables are unaffected. The default precision is set to 53 bits initially.

Return the current default MPFR precision in bits.

Mlmpfr.get_prec x returns the precision of x. The corresponding Mlmpfr.set_prec x prec function is not allowed, use Mlmpfr.make_from_mpfr ~prec:prec x instead.

Return a fresh mpfr_float number of precision ~prec (optional), made from another mpfr_float number, in direction ~rnd (optional).

Return a fresh mpfr_float number of precision ~prec (optional), made from an int, in direction ~rnd (optional).

Return a fresh mpfr_float number of precision ~prec (optional), made from a float, in direction ~rnd (optional).

Mlmpfr.make_from_str s ~base:b ~prec:p ~rnd:r returns a fresh mpfr_float of precision p from the string value s in base b, rounded in direction r (p, b, and r are optional).

Return a NaN with precision ~prec if provided, otherwise default precision is used.

Return a infinity with precision ~prec if provided, otherwise default precision is used.

Return a zero with precision ~prec if provided, otherwise default precision is used.

Conversion to a float.

Conversion to an int.

Mlmpfr.get_float_2exp x returns (n, exp) such that 0.5 <= |n| < 1 and n times 2 raised to exp equals x rounded to float precision.

Mlmpfr.get_mpfr_2exp x returns (n, exp) such that 0.5 <= |n| < 1 and n times 2 raised to exp equals x rounded to ~prec precision.

Mlmpfr.get_str ~rnd:r ~base:b ~size:s x converts x to a tuple (frac, exp), where frac is a fraction (a string of digits in base b) with rounding to direction r, and exp is an exponent. s is the number of significand digits output in frac. If s is zero, the number of digits of the significand is chosen large enough so that re-reading the printed value with the same precision, assuming both output and input use rounding to nearest, will recover the original value of x. Decimal is the default base and default size is zero.

Mlmpfr.get_str_ndigits b p returns 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.

Mlmpfr.get_formatted_str is identical to Mlmpfr.get_str except that it returns a full-formatted string (equivalent to mpfr_printf("%Re", x)). Set ktz to false to remove trailing zeroes.

Return true if the mpfr_float would fit in a int, when rounded to an integer in the direction ~rnd.

Addition of two mpfr_float.

Addition of a mpfr_float and an int.

Addition of a mpfr_float and a float.

Subtraction of two mpfr_float.

Subtraction of a mpfr_float and an int.

Subtraction of an int and a mpfr_float.

Addition of a mpfr_float and a float.

Subtraction of a float and an mpfr_float.

Multiplication of two mpfr_float.

Multiplication of a mpfr_float and an int.

Multiplication of an int and a mpfr_float.

Division of two mpfr_float.

Division of a mpfr_float by an int.

Division of an int by a mpfr_float.

Division of an int by a mpfr_float.

Division of a float by a mpfr_float.

Return the square root of a mpfr_float number.

Return the square root of an int. Return nan if negative.

Return the reciprocal square root of an mpfr_float number.

Returns the cubic root of an mpfr_float number.

Mlmpfr.rootn_int x k returns the k-th root of x.

Compute the negation of an mpfr_float number.

Compute the absolute value of an mpfr_float number.

Mlmpfr.dim x y returs the positive difference of x and y, i.e., x - y if x > y, +0 if x <= y, and NaN if x or y is NaN.

Mlmpfr.mul_2int x y returns x times 2 raised to y.

Mlmpfr.div_2int x y returns x divided by 2 raised to y.

Return the factorial of an int. Return NaN if input is negative.

Return the fused multiply and add of mpfr_float numbers. Mlmpfr.fma x y z retuns xy+z.

Return the fused multiply and sub of mpfr_float numbers. Mlmpfr.fms x y z retuns xy-z.

Mlmpfr.fmma x y z t retuns xy+zt. In case the computation of xy overflows or underflows (or that of zt), the result is computed as if the two intermediate products were computed with rounding toward zero.

Mlmpfr.fmms x y z t retuns xy-zt. See Mlmpfr.fmma for further comments

Return the Euclidean norm of a mpfr_float number.

Return the sum of all the elements of the list.

Return the dot product of the lists (commun size of the list is determined by the size of the smallest one).

Mlmpfr.cmp a b returns a positive value if a > b, zero if a = b, and a negative value if a < b. If one of the operands is NaN, set the Erange flag and return zero.

Mlmpfr.cmp_int a b compares a and b. Similar as above.

Mlmpfr.cmp_float a b compares a and b. Similar as above.

Mlmpfr.cmp_int_2exp a b e compares a and b multiplied by two to the power e. Similar as above.

Mlmpfr.cmpabs a b returns a positive value if |a| > |b|, zero if |a| = |b|, and a negative value if |a| < |b|.

Mlmpfr.cmpabs_int a b compares a and b. Similar as above.

Its a NaN.

Its an infinity.

Its a ordinary number (i.e., neither NaN nor an infinity).

It's a zero.

Its a regular number (i.e., neither NaN, nor an infinity nor zero).

Return the sign of a mpfr_float number.

Operator > in MPFR syntax style.

Operator >=in MPFR syntax style.

Operator < in MPFR syntax style.

Operator <= in MPFR syntax style.

Operator = in MPFR syntax style.

Operator <> in MPFR syntax style.

Return true if the operands are comparable (i.e. one of them is a NaN), false otherwise.

This function implements the totalOrder predicate from IEEE 754-2008.

Return the natural logarithm of a mpfr_float.

Return the natural logarithm of an int.

Return the log2 of a mpfr_float.

Return the log10 of a mpfr_float.

Return the logarithm of one plus a mpfr_float.

Return the exponential of a mpfr_float.

Return the 2 power of a mpfr_float.

Return the 10 power of a mpfr_float.

Return the exponential of a mpfr_float followed by a subtraction by one.

Mlmpfr.pow x y returns x raised to y.

Mlmpfr.pow_int x y returns x raised to y.

Return the cosine of a mpfr_float.

Return the sine of a mpfr_float.

Return the tangent of a mpfr_float.

Mlmpfr.cosu x u returns the cosine of a x multiplied by Pi and divided by u.

Mlmpfr.sinu x u returns the cosine of a x multiplied by Pi and divided by u.

Mlmpfr.tanu x u returns the cosine of a x multiplied by Pi and divided by u.

Return the cosine of a mpfr_float multiplied by Pi.

Return the sine of a mpfr_float multiplied by Pi.

Return the tangent of a mpfr_float multiplied by Pi.

Return simultaneously the sine and cosine of an mpfr_float number.

Return the secant of a mpfr_float.

Return the cosecant of a mpfr_float.

Return the cotangent of a mpfr_float.

Return the arc-cosine of a mpfr_float.

Return the arc-sine of a mpfr_float.

Return the arc-tangent of a mpfr_float.

Mlmpfr.acosu x u returns a mpfr_float set to a multiplied by u and divided by 2 Pi, where a is the arc-cosine of x

Mlmpfr.acosu x u returns a mpfr_float set to a multiplied by u and divided by 2 Pi, where a is the arc-sine of x

Mlmpfr.acosu x u returns a mpfr_float set to a multiplied by u and divided by 2 Pi, where a is the arc-tangent of x

Return the arc-cosine of a mpfr_float divided by Pi.

Return the arc-sine of a mpfr_float divided by Pi.

Return the arc-tangent of a mpfr_float divided by Pi.

Mlmpfr.atan2 x y returns the arc-tangent2 of x and y.

Mlmpfr.atan2u x y u returns the arc-tangent2 of x and y, multiplied by u and divided by 2 Pi.

Mlmpfr.atan2pi x y is the same as Mlmpfr.atan2u x y u with u = 2.

Return the hyperbolic cosine of a mpfr_float.

Return the hyperbolic sine of a mpfr_float.

Return the hyperbolic tangent of a mpfr_float.

Return simultaneously the sine and cosine of an mpfr_float number.

Return the hyperbolic secant of a mpfr_float.

Return the hyperboloc cosecant of a mpfr_float.

Return the hyperbolic cotangent of a mpfr_float.

Return the inverse hyperbolic cosine of a mpfr_float.

Return the inverse hyperbolic sine of a mpfr_float.

Return the inverse hyperbolic tangent of a mpfr_float.

Return the exponential integral of a mpfr_float.

Return the real part of the dilogarithm of a mpfr_float.

Return the Gamma function on a mpfr_float.

Mlmpfr.gamma_inc x y returns the incomplete Gamma function on x and y.

Return the logarithm of the Gamma function on a mpfr_float.

Return the logarithm of the absolute value of the Gamma function and the sign of the Gamma function on a mpfr_float.

Return the Digamma (sometimes also called Psi) function on a mpfr_float.

Mlmpfr.beta op1 op2 returns the Beta function at arguments op1 and op2.

Return the Riemann Zeta function on a mpfr_float.

Return the error function on a mpfr_float.

Return the complementary error function on a mpfr_float.

Return the value of the first kind Bessel function of order 0 on a mpfr_float.

Return the value of the first kind Bessel function of order 1 on a mpfr_float.

Mlmpfr.jn n x returns the value of the first kind Bessel function of order n on x. Return NaN if n is negative.

Return the value of the second kind Bessel function of order 0 on a mpfr_float.

Return the value of the second kind Bessel function of order 1 on a mpfr_float.

Mlmpfr.jn n x returns the value of the second kind Bessel function of order n on x. Return NaN if n is negative.

Return the arithmetic-geometric mean of a mpfr_float number.

Return the value of the Airy function Ai on a mpfr_float number.

Return the logarithm of 2.

Return the value of Pi.

Return the value of Euler's constant 0.577...

Return the value of Catalan's constant 0.915...

Mlmpfr.out_str stdout b s x Mlmpfr.To_Nearest outputs x, in base b, to stdout, in the direction Mlmpfr.To_Nearest. The size of the printed output is s digits long. It uses Printf.fprintf and Mlmpfr.get_formatted_string.

Mlmpfr.inp_str stdin b p Mlmpfr.To_Nearest returns a mpfr_float number of precision p from a string in base b read on stdin. It uses Pervasives.input_line and Mlmpfr.make_from_str.

Mlmpfr.fpif_export chan op exports the number op to the stream chan in a floating-point interchange format. In particular one can export on a 32-bit computer and import on a 64-bit computer, or export on a little-endian computer and import on a big-endian computer. The precision of op and the sign bit of a NaN are stored too.

Mlmpfr.fpif_import chan imports a mpfr_float number from the stream chan in a floating-point interchange format (see Mlmpfr.mpfr_fpif_export). Note that the precision of op is set to the one read from the stream, and the sign bit is always retrieved (even for NaN). If the stored precision is zero or greater than Mlmpfr.mpfr_prec_max, the function fails (its ternary value is non-zero) and op is undefined. If the function fails for another reason, op is set to NaN. Ternary value is 0 iff the import was successful.

Retrun the input rounded to an integer, i.e. the nearest representable integer in the direction ~rnd.

Retrun the input rounded to an integer, i.e. the next higher or equal representable integer.

Retrun the input rounded to an integer, i.e. the next lower or equal representable integer.

Retrun the input rounded to an integer, i.e. the nearest representable integer (rounding halfway cases away from zero as in the roundTiesToAway mode of IEEE 754-2008).

Retrun the input rounded to an integer, i.e. the nearest representable integer (rounding halfway cases athe even-rounding rule).

Retrun the input rounded to an integer, i.e. the nearest representable integer toward zero.

Retrun the input rounded to an integer, i.e. the next higher or equal representable integer. If the result is not representable, it is rounded in the direction ~rnd

Retrun the input rounded to an integer, i.e. the next lower or equal representable integer. If the result is not representable, it is rounded in the direction ~rnd

Retrun the input rounded to an integer, i.e. the nearest representable integer (rounding halfway cases away from zero). If the result is not representable, it is rounded in the direction ~rnd

Retrun the input rounded to an integer, i.e. the nearest representable integer (rounding halfway cases to the nearest even integer). If the result is not representable, it is rounded in the direction ~rnd

Retrun the input rounded to an integer, i.e. the next integer toward zero. If the result is not representable, it is rounded in the direction ~rnd

Return the fractional part of an mpfr_float (with the same sign).

Return simultaneously the integral part and the fractional part of an mpfr_float.

Mlmpfr.fmod x y returns the value x - ny, where n is the integer quotient of x / y (rounded toward zero).

Mlmpfr.fmodquo x y returns the tuple (x - ny, q). See Mlmpfr.remquo for the meanings of n and q.

Mlmpfr.remainder x y returns the value x - ny, where n is the integer quotient of x / y (rounded to the nearest integer, ties rounded to even).

Mlmpfr.remquo x y returns the tuple (x - ny, q), where n is the integer quotient of x / y (rounded to the nearest integer, ties rounded to even), and q are the low significant bits from the quotient n with the sign of x divided by y (except if those low bits are all zero, in which case zero is returned).

Return true iff the input mpfr_float is an integer.

Set the default rounding mode. The default rounding mode is to nearest initially.

Get the default rounding mode.

Mlmpfr.prec_round ~rnd:r x p rounds x according to r with precision p.

Assuming b is an approximation of an unknown mpfr_number x in the direction r1 with error at most two to the power E(b)-err where E(b) is the exponent of b, return true if Mlmpfr.can_round x err r1 r2 p is able to round correctly x to precision p with the direction r2, and false otherwise (including for NaN and Inf).

Return the minimal number of bits required to store the significand of an mpfr_float, and 0 for special values, including 0.

Return a MPFR-like string ("MPFR_RNDD", "MPFR_RNDU", "MPFR_RNDN", "MPFR_RNDZ", "MPFR_RNDA") corresponding to the (Toward_Minus_Infinity, Toward_Plus_Infinity, To_Nearest, Toward_Zero, Away_From_Zero) rounding modes.

Return ternary value as a string ("Correct", "Lower", and "Greater" for Correct_Rounding, Lower, and Greater, respectively).

Mlmpfr.nexttoward x y returns NaN if x or y is NaN, returns a copy of x if x and y are equal. Otherwise, if x is different from y, return the next floating-point number of x (with the precision of x and the current exponent range) in the direction of y (the infinite values are seen as the smallest and largest floating-point numbers). If the result is zero, it keeps the sign of x. No underflow or overflow is generated.

Equivalent to Mlmpfr.nexttoward where y is plus infinity.

Equivalent to Mlmpfr.nexttoward where y is minus infinity.

Return the minimum of two mpfr_float. If operands are both NaN, then return NaN. If one operand is NaN, then return the other value. If operands are zeros of different signs, then return -0.

Return the maximum of two mpfr_float. If operands are both NaN, then return NaN. If one operand is NaN, then return the other value. If operands are zeros of different signs, then return +0.

Return the exponent of a mpfr_float.

Return a fresh mpfr_float from input with new precision.

Return the sign of a mpfr_float.

Mlmpfr.setsign x s ~rnd:r returns a fresh copy of x with the sign s, with precision p in direction r.

Mlmpfr.copysign x y ~rnd:r returns a fresh copy of x with the sign of y, with precision p in direction r.

Return the MPFR version.

Return the (current) smallest exponent allowed for a mpfr_float.

Return the (current) largest exponent allowed for a mpfr_float.

Set the smallest exponent allowed for a mpfr_float.

Set the largest exponent allowed for a mpfr_float.

Return the minimum of the exponents allowed for Mlmpfr.set_emin.

Return the maximum of the exponents allowed for Mlmpfr.set_emin.

Return the minimum of the exponents allowed for Mlmpfr.set_emax.

Return the maximum of the exponents allowed for Mlmpfr.set_emax.

Mlmpfr.check_range ~rnd:r x assumes that x is the correctly-rounded value of some real value y in the direction r and some extended exponent range. Note that this function doesn't modify x as mpfr does (it returns a copy, or fails with Error).

Mlmpfr.subnormalize ~rnd:r x rounds x emulating subnormal number arithmetic: if x is outside the subnormal exponent range, it just return a copy of x; otherwise, it returns a roudning of x to precision EXP(x)-emin+1 according to rounding mode r. Note that this function doesn't modify x as mpfr does (it returns a copy, or fails with Error).

Clear the underflow flag.

Clear the overflow flag.

Clear the divide-by-zero flag.

Clear the invalid flag.

Clear the inexact flag.

Clear the erange flag.

Clear all global flags.

Set the underflow flag.

Set the overflow flag.

Set the divide-by-zero flag.

Set the invalid flag.

Set the inexact flag.

Set the erange flag.

Is underflow flag set?

Is overflow flag set?

Is divide-by-zero flag set?

Is invalid flag set?

Is inexact flag set?

Is erange flag set?

Mlmpfr.flags_clear f clears (lowers) the group of flags specified by mask f.

Mlmpfr.flags_clear f sets (raises) the group of flags specified by mask f.

Return the flags specified by mask.

Return all the flags. It is equivalent to Mlmpfr.flags_test [Mlmpfr.All].

Mlmpfr.flags_restore f1 f2 restores the flags specified by mask f2 to their state represented in flags f1.

Free all caches and pools used by MPFR internally.