# doc-cache created by Octave 11.1.0
# name: cache
# type: cell
# rows: 3
# columns: 265
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
MPFR_RNDA


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 101
 ret = MPFR_RNDA ()

 Return internal numerical value for the rounding mode
 "round away from zero".



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
 ret = MPFR_RNDA ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
MPFR_RNDD


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 133
 ret = MPFR_RNDD ()

 Return internal numerical value for the rounding mode
 "round toward zero" (roundTowardZero in IEEE 754-2008).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
 ret = MPFR_RNDD ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
MPFR_RNDN


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 161
 ret = MPFR_RNDN ()

 Return internal numerical value for the rounding mode
 "round to nearest", with the even rounding rule (roundTiesToEven in IEEE 754-2008).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
 ret = MPFR_RNDN ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
MPFR_RNDU


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 146
 ret = MPFR_RNDU ()

 Return internal numerical value for the rounding mode
 "round toward plus infinity" (roundTowardPositive in IEEE 754-2008).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
 ret = MPFR_RNDU ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
MPFR_RNDZ


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 147
 ret = MPFR_RNDZ ()

 Return internal numerical value for the rounding mode
 "round toward minus infinity" (roundTowardNegative in IEEE 754-2008).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
 ret = MPFR_RNDZ ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
apa


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 500
 Set or get APA settings.

 'verbose' (integer scalar):

   0 : no output at all (including no error messages)
   1 : show error messages
  [2]: show error messages and precision warnings [default]
   3 : very verbose debug output.

  'format.fmt' (string): ['fixed-point'], 'scientific'
  'format.base'          (integer scalar): 2 ... [10] ... 62
  'format.inner_padding' (integer scalar): positive
  'format.break_at_col'  (integer scalar): positive

 Use 'clear apa' to reset to default values.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
 Set or get APA settings.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
gmp_version


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 ret = gmp_version ()




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
 ret = gmp_version ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
install_apa


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 269
 Install GMP and MPFR MEX interface.

   'rebuild'  -  Rebuild and overwrite the MEX interface.

 After installation, find the version of dynamically linked GMP and MPFR libraries with

    >> gmp_version ()
    ans = 6.3.0

    >> mpfr_get_version ()
    ans = 4.2.1




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 Install GMP and MPFR MEX interface.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mex_apa_interface


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 523
 Help file for the GMP and MPFR MEX-interface.

 Octave/Matlab MEX interface for MPFR.

    https://www.mpfr.org/mpfr-4.1.0/mpfr.html

 The original order of arguments is preserved.  For example

    int mpfr_add (mpfr_t rop, mpfr_t op1, mpfr_t op2, mpfr_rnd_t rnd)

 can be called via m-file functions

    rop = mpfr_t (zeros (3));
    op1 = mpfr_t (ones (3));
    op2 = mpfr_t (4 * eye (3));
    rnd = mpfr_default_rounding_mode ();

    ret = mpfr_add (rop, op1, op2, rnd)

 where rop, op1, op2 are @mpfr_t variables.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
 Help file for the GMP and MPFR MEX-interface.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_abs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 545
 ret = mpfr_abs (rop, op, rnd)

 Set ROP to -OP and the absolute value of OP respectively, rounded
 in the direction RND.  Just changes or adjusts the sign if ROP and
 OP are the same variable, otherwise a rounding might occur if the
 precision of ROP is less than that of OP.

 The sign rule also applies to NaN in order to mimic the IEEE 754
 ‘negate’ and ‘abs’ operations, i.e., for ‘mpfr_neg’, the sign is
 reversed, and for ‘mpfr_abs’, the sign is set to positive.  But
 contrary to IEEE 754, the NaN flag is set as usual.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_abs (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_acos


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 567
 ret = mpfr_acos (rop, op, rnd)

 Set ROP to the arc-cosine, arc-sine or arc-tangent of OP, rounded
 in the direction RND.  Note that since ‘acos(-1)’ returns the
 floating-point number closest to Pi according to the given rounding
 mode, this number might not be in the output range 0 <= ROP < Pi of
 the arc-cosine function; still, the result lies in the image of the
 output range by the rounding function.  The same holds for
 ‘asin(-1)’, ‘asin(1)’, ‘atan(-Inf)’, ‘atan(+Inf)’ or for ‘atan(op)’
 with large OP and small precision of ROP.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_acos (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_acosh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 132
 ret = mpfr_acosh (rop, op, rnd)

 Set ROP to the inverse hyperbolic cosine, sine or tangent of OP,
 rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_acosh (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_add


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 492
 ret = mpfr_add (rop, op1, op2, rnd)

 Set ROP to OP1 + OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) + 0 =
 (+0) and (−0) + 0 = (−0)).  The ‘mpfr_add_d’ function assumes that
 the radix of the ‘double’ type is a power of 2, with a precision at
 most that declared by the C implementation (macro
 ‘IEEE_DBL_MANT_DIG’, and if not defined 53 bits).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_add (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_add_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 494
 ret = mpfr_add_d (rop, op1, op2, rnd)

 Set ROP to OP1 + OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) + 0 =
 (+0) and (−0) + 0 = (−0)).  The ‘mpfr_add_d’ function assumes that
 the radix of the ‘double’ type is a power of 2, with a precision at
 most that declared by the C implementation (macro
 ‘IEEE_DBL_MANT_DIG’, and if not defined 53 bits).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_add_d (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_add_si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 495
 ret = mpfr_add_si (rop, op1, op2, rnd)

 Set ROP to OP1 + OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) + 0 =
 (+0) and (−0) + 0 = (−0)).  The ‘mpfr_add_d’ function assumes that
 the radix of the ‘double’ type is a power of 2, with a precision at
 most that declared by the C implementation (macro
 ‘IEEE_DBL_MANT_DIG’, and if not defined 53 bits).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_add_si (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_add_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 495
 ret = mpfr_add_ui (rop, op1, op2, rnd)

 Set ROP to OP1 + OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) + 0 =
 (+0) and (−0) + 0 = (−0)).  The ‘mpfr_add_d’ function assumes that
 the radix of the ‘double’ type is a power of 2, with a precision at
 most that declared by the C implementation (macro
 ‘IEEE_DBL_MANT_DIG’, and if not defined 53 bits).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_add_ui (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_agm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 507
 ret = mpfr_agm (rop, op1, op2, rnd)

 Set ROP to the arithmetic-geometric mean of OP1 and OP2, rounded in
 the direction RND.  The arithmetic-geometric mean is the common
 limit of the sequences U_N and V_N, where U_0=OP1, V_0=OP2, U_(N+1)
 is the arithmetic mean of U_N and V_N, and V_(N+1) is the geometric
 mean of U_N and V_N.  If any operand is negative and the other one
 is not zero, set ROP to NaN.  If any operand is zero and the other
 one is finite (resp. infinite), set ROP to +0 (resp. NaN).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_agm (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
mpfr_ai


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 422
 ret = mpfr_ai (rop, x, rnd)

 Set ROP to the value of the Airy function Ai on X, rounded in the
 direction RND.  When X is NaN, ROP is always set to NaN.  When X is
 +Inf or −Inf, ROP is +0.  The current implementation is not
 intended to be used with large arguments.  It works with abs(X)
 typically smaller than 500.  For larger arguments, other methods
 should be used and will be implemented in a future version.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
 ret = mpfr_ai (rop, x, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_asin


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 567
 ret = mpfr_asin (rop, op, rnd)

 Set ROP to the arc-cosine, arc-sine or arc-tangent of OP, rounded
 in the direction RND.  Note that since ‘acos(-1)’ returns the
 floating-point number closest to Pi according to the given rounding
 mode, this number might not be in the output range 0 <= ROP < Pi of
 the arc-cosine function; still, the result lies in the image of the
 output range by the rounding function.  The same holds for
 ‘asin(-1)’, ‘asin(1)’, ‘atan(-Inf)’, ‘atan(+Inf)’ or for ‘atan(op)’
 with large OP and small precision of ROP.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_asin (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_asinh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 132
 ret = mpfr_asinh (rop, op, rnd)

 Set ROP to the inverse hyperbolic cosine, sine or tangent of OP,
 rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_asinh (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_atan


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 567
 ret = mpfr_atan (rop, op, rnd)

 Set ROP to the arc-cosine, arc-sine or arc-tangent of OP, rounded
 in the direction RND.  Note that since ‘acos(-1)’ returns the
 floating-point number closest to Pi according to the given rounding
 mode, this number might not be in the output range 0 <= ROP < Pi of
 the arc-cosine function; still, the result lies in the image of the
 output range by the rounding function.  The same holds for
 ‘asin(-1)’, ‘asin(1)’, ‘atan(-Inf)’, ‘atan(+Inf)’ or for ‘atan(op)’
 with large OP and small precision of ROP.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_atan (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_atan2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1520
 ret = mpfr_atan2 (rop, y, x, rnd)

 Set ROP to the arc-tangent2 of Y and X, rounded in the direction
 RND: if ‘x > 0’, ‘atan2(y, x) = atan(y/x)’; if ‘x < 0’, ‘atan2(y,
 x) = sign(y)*(Pi - atan(abs(y/x)))’, thus a number from -Pi to Pi.
 As for ‘atan’, in case the exact mathematical result is +Pi or -Pi,
 its rounded result might be outside the function output range.

 ‘atan2(y, 0)’ does not raise any floating-point exception.  Special
 values are handled as described in the ISO C99 and IEEE 754-2008
 standards for the ‘atan2’ function:
 • ‘atan2(+0, -0)’ returns +Pi.
 • ‘atan2(-0, -0)’ returns -Pi.
 • ‘atan2(+0, +0)’ returns +0.
 • ‘atan2(-0, +0)’ returns −0.
 • ‘atan2(+0, x)’ returns +Pi for x < 0.
 • ‘atan2(-0, x)’ returns -Pi for x < 0.
 • ‘atan2(+0, x)’ returns +0 for x > 0.
 • ‘atan2(-0, x)’ returns −0 for x > 0.
 • ‘atan2(y, 0)’ returns -Pi/2 for y < 0.
 • ‘atan2(y, 0)’ returns +Pi/2 for y > 0.
 • ‘atan2(+Inf, -Inf)’ returns +3*Pi/4.
 • ‘atan2(-Inf, -Inf)’ returns -3*Pi/4.
 • ‘atan2(+Inf, +Inf)’ returns +Pi/4.
 • ‘atan2(-Inf, +Inf)’ returns -Pi/4.
 • ‘atan2(+Inf, x)’ returns +Pi/2 for finite x.
 • ‘atan2(-Inf, x)’ returns -Pi/2 for finite x.
 • ‘atan2(y, -Inf)’ returns +Pi for finite y > 0.
 • ‘atan2(y, -Inf)’ returns -Pi for finite y < 0.
 • ‘atan2(y, +Inf)’ returns +0 for finite y > 0.
 • ‘atan2(y, +Inf)’ returns −0 for finite y < 0.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_atan2 (rop, y, x, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_atanh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 132
 ret = mpfr_atanh (rop, op, rnd)

 Set ROP to the inverse hyperbolic cosine, sine or tangent of OP,
 rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_atanh (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_beta


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 243
 ret = mpfr_beta (rop, op1, op2, rnd)

 Set ROP to the value of the Beta function at arguments OP1 and OP2.
 Note: the current code does not try to avoid internal overflow or
 underflow, and might use a huge internal precision in some cases.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_beta (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
mpfr_buildopt_decimal_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 216
 ret = mpfr_buildopt_decimal_p ()

 Return a non-zero value if MPFR was compiled with decimal float
 support (that is, MPFR was built with the ‘--enable-decimal-float’
 configure option), return zero otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_buildopt_decimal_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
mpfr_buildopt_float128_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 214
 ret = mpfr_buildopt_float128_p ()

 Return a non-zero value if MPFR was compiled with ‘_Float128’
 support (that is, MPFR was built with the ‘--enable-float128’
 configure option), return zero otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_buildopt_float128_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
mpfr_buildopt_gmpinternals_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 242
 ret = mpfr_buildopt_gmpinternals_p ()

 Return a non-zero value if MPFR was compiled with GMP internals
 (that is, MPFR was built with either ‘--with-gmp-build’ or
 ‘--enable-gmp-internals’ configure option), return zero otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_buildopt_gmpinternals_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
mpfr_buildopt_sharedcache_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 416
 ret = mpfr_buildopt_sharedcache_p ()

 Return a non-zero value if MPFR was compiled so that all threads
 share the same cache for one MPFR constant, like ‘mpfr_const_pi’ or
 ‘mpfr_const_log2’ (that is, MPFR was built with the
 ‘--enable-shared-cache’ configure option), return zero otherwise.
 If the return value is non-zero, MPFR applications may need to be
 compiled with the ‘-pthread’ option.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_buildopt_sharedcache_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
mpfr_buildopt_tls_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 265
 ret = mpfr_buildopt_tls_p ()

 Return a non-zero value if MPFR was compiled as thread safe using
 compiler-level Thread-Local Storage (that is, MPFR was built with
 the ‘--enable-thread-safe’ configure option, see ‘INSTALL’ file),
 return zero otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_buildopt_tls_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
mpfr_buildopt_tune_case


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 172
 ret = mpfr_buildopt_tune_case ()

 Return a string saying which thresholds file has been used at
 compile time.  This file is normally selected from the processor
 type.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_buildopt_tune_case ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_can_round


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1963
 ret = mpfr_can_round (b, err, rnd1, rnd2, prec)

 Assuming B is an approximation of an unknown number X in the
 direction RND1 with error at most two to the power E(b)-ERR where
 E(b) is the exponent of B, return a non-zero value if one is able
 to round correctly X to precision PREC with the direction RND2
 assuming an unbounded exponent range, and 0 otherwise (including
 for NaN and Inf).  In other words, if the error on B is bounded by
 two to the power K ulps, and B has precision PREC, you should give
 ERR=PREC−K.  This function *does not modify* its arguments.

 If RND1 is ‘MPFR_RNDN’ or ‘MPFR_RNDF’, the error is considered to
 be either positive or negative, thus the possible range is twice as
 large as with a directed rounding for RND1 (with the same value of
 ERR).

 When RND2 is ‘MPFR_RNDF’, let RND3 be the opposite direction if
 RND1 is a directed rounding, and ‘MPFR_RNDN’ if RND1 is ‘MPFR_RNDN’
 or ‘MPFR_RNDF’.  The returned value of ‘mpfr_can_round (b, err,
 rnd1, MPFR_RNDF, prec)’ is non-zero iff after the call ‘mpfr_set
 (y, b, rnd3)’ with Y of precision PREC, Y is guaranteed to be a
 faithful rounding of X.

 Note: The *note ternary value:: cannot be determined in general
 with this function.  However, if it is known that the exact value
 is not exactly representable in precision PREC, then one can use
 the following trick to determine the (non-zero) ternary value in
 any rounding mode RND2 (note that ‘MPFR_RNDZ’ below can be replaced
 by any directed rounding mode):
 Indeed, if RND2 is ‘MPFR_RNDN’, this will check if one can round to
 PREC+1 bits with a directed rounding: if so, one can surely round
 to nearest to PREC bits, and in addition one can determine the
 correct ternary value, which would not be the case when B is near
 from a value exactly representable on PREC bits.

 A detailed example is available in the ‘examples’ subdirectory,
 file ‘can_round.c’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
 ret = mpfr_can_round (b, err, rnd1, rnd2, prec)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_cbrt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 679
 ret = mpfr_cbrt (rop, op, rnd)

 Set ROP to the Nth root (with N = 3, the cubic root, for
 ‘mpfr_cbrt’) of OP rounded in the direction RND.  For N = 0, set
 ROP to NaN.  For N odd (resp. even) and OP negative (including
 −Inf), set ROP to a negative number (resp. NaN).  If OP is zero,
 set ROP to zero with the sign obtained by the usual limit rules,
 i.e., the same sign as OP if N is odd, and positive if N is even.

 These functions agree with the rootn function of the IEEE 754-2008
 standard and the P754/D2.41 draft of the next standard
 (Section 9.2).  Note that it is here restricted to N >= 0.
 Functions allowing a negative N may be implemented in the future.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_cbrt (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_ceil


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1854
 ret = mpfr_ceil (rop, op)

 Set ROP to OP rounded to an integer.  ‘mpfr_rint’ rounds to the
 nearest representable integer in the given direction RND, and the
 other five functions behave in a similar way with some fixed
 rounding mode:
 • ‘mpfr_ceil’: to the next higher or equal representable integer
 • ‘mpfr_floor’ to the next lower or equal representable integer
 • ‘mpfr_round’ to the nearest representable integer, rounding
 • ‘mpfr_roundeven’ to the nearest representable integer,
 • ‘mpfr_trunc’ to the next representable integer toward zero
 When OP is a zero or an infinity, set ROP to the same value (with
 the same sign).

 The return value is zero when the result is exact, positive when it
 is greater than the original value of OP, and negative when it is
 smaller.  More precisely, the return value is 0 when OP is an
 integer representable in ROP, 1 or −1 when OP is an integer that is
 not representable in ROP, 2 or −2 when OP is not an integer.

 When OP is NaN, the NaN flag is set as usual.  In the other cases,
 the inexact flag is set when ROP differs from OP, following the ISO
 C99 rule for the ‘rint’ function.  If you want the behavior to be
 more like IEEE 754 / ISO TS 18661-1, i.e., the usual behavior where
 the round-to-integer function is regarded as any other mathematical
 function, you should use one the ‘mpfr_rint_*’ functions instead.

 Note that no double rounding is performed; for instance, 10.5
 (1010.1 in binary) is rounded by ‘mpfr_rint’ with rounding to
 nearest to 12 (1100 in binary) in 2-bit precision, because the two
 enclosing numbers representable on two bits are 8 and 12, and the
 closest is 12.  (If one first rounded to an integer, one would
 round 10.5 to 10 with even rounding, and then 10 would be rounded
 to 8 again with even rounding.)




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
 ret = mpfr_ceil (rop, op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_check_range


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1330
 ret = mpfr_check_range (x, t, rnd)

 This function assumes that X is the correctly rounded value of some
 real value Y in the direction RND and some extended exponent range,
 and that T is the corresponding *note ternary value::.  For
 example, one performed ‘t = mpfr_log (x, u, rnd)’, and Y is the
 exact logarithm of U.  Thus T is negative if X is smaller than Y,
 positive if X is larger than Y, and zero if X equals Y.  This
 function modifies X if needed to be in the current range of
 acceptable values: It generates an underflow or an overflow if the
 exponent of X is outside the current allowed range; the value of T
 may be used to avoid a double rounding.  This function returns zero
 if the new value of X equals the exact one Y, a positive value if
 that new value is larger than Y, and a negative value if it is
 smaller than Y.  Note that unlike most functions, the new result X
 is compared to the (unknown) exact one Y, not the input value X,
 i.e., the ternary value is propagated.

 Note: If X is an infinity and T is different from zero (i.e., if
 the rounded result is an inexact infinity), then the overflow flag
 is set.  This is useful because ‘mpfr_check_range’ is typically
 called (at least in MPFR functions) after restoring the flags that
 could have been set due to internal computations.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
 ret = mpfr_check_range (x, t, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_clear


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 206
 mpfr_clear (varargin)

 This function does nothing (NOP)!

 Free the space occupied by the significand of X.  Make sure to call
 this function for all ‘mpfr_t’ variables when you are done with
 them.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
 mpfr_clear (varargin)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_clear_divby0


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 118
 mpfr_clear_divby0 ()

 Clear (lower) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
 mpfr_clear_divby0 ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
mpfr_clear_erangeflag


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 122
 mpfr_clear_erangeflag ()

 Clear (lower) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
 mpfr_clear_erangeflag ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_clear_flags


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 196
 mpfr_clear_flags ()

 Clear (lower) all global flags (underflow, overflow,
 divide-by-zero, invalid, inexact, _erange_).  Note: a group of
 flags can be cleared by using ‘mpfr_flags_clear’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
 mpfr_clear_flags ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
mpfr_clear_inexflag


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 120
 mpfr_clear_inexflag ()

 Clear (lower) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 mpfr_clear_inexflag ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
mpfr_clear_nanflag


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 119
 mpfr_clear_nanflag ()

 Clear (lower) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
 mpfr_clear_nanflag ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
mpfr_clear_overflow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 120
 mpfr_clear_overflow ()

 Clear (lower) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 mpfr_clear_overflow ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
mpfr_clear_underflow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 121
 mpfr_clear_underflow ()

 Clear (lower) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
 mpfr_clear_underflow ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_clears


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 402
 mpfr_clears (varargin)

 This function does nothing (NOP)!

 Free the space occupied by all the ‘mpfr_t’ variables of the given
 ‘va_list’.  See ‘mpfr_clear’ for more details.  The ‘va_list’ is
 assumed to be composed only of type ‘mpfr_t’ (or equivalently
 ‘mpfr_ptr’).  It begins from X, and ends when it encounters a null
 pointer (whose type must also be ‘mpfr_ptr’).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 mpfr_clears (varargin)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_cmp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 720
 ret = mpfr_cmp (op1, op2)

 Compare OP1 and OP2.  Return a positive value if OP1 > OP2, zero if
 OP1 = OP2, and a negative value if OP1 < OP2.  Both OP1 and OP2 are
 considered to their full own precision, which may differ.  If one
 of the operands is NaN, set the _erange_ flag and return zero.

 Note: These functions may be useful to distinguish the three
 possible cases.  If you need to distinguish two cases only, it is
 recommended to use the predicate functions (e.g., ‘mpfr_equal_p’
 for the equality) described below; they behave like the IEEE 754
 comparisons, in particular when one or both arguments are NaN.  But
 only floating-point numbers can be compared (you may need to do a
 conversion first).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
 ret = mpfr_cmp (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_cmp_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 722
 ret = mpfr_cmp_d (op1, op2)

 Compare OP1 and OP2.  Return a positive value if OP1 > OP2, zero if
 OP1 = OP2, and a negative value if OP1 < OP2.  Both OP1 and OP2 are
 considered to their full own precision, which may differ.  If one
 of the operands is NaN, set the _erange_ flag and return zero.

 Note: These functions may be useful to distinguish the three
 possible cases.  If you need to distinguish two cases only, it is
 recommended to use the predicate functions (e.g., ‘mpfr_equal_p’
 for the equality) described below; they behave like the IEEE 754
 comparisons, in particular when one or both arguments are NaN.  But
 only floating-point numbers can be compared (you may need to do a
 conversion first).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
 ret = mpfr_cmp_d (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_cmp_ld


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 723
 ret = mpfr_cmp_ld (op1, op2)

 Compare OP1 and OP2.  Return a positive value if OP1 > OP2, zero if
 OP1 = OP2, and a negative value if OP1 < OP2.  Both OP1 and OP2 are
 considered to their full own precision, which may differ.  If one
 of the operands is NaN, set the _erange_ flag and return zero.

 Note: These functions may be useful to distinguish the three
 possible cases.  If you need to distinguish two cases only, it is
 recommended to use the predicate functions (e.g., ‘mpfr_equal_p’
 for the equality) described below; they behave like the IEEE 754
 comparisons, in particular when one or both arguments are NaN.  But
 only floating-point numbers can be compared (you may need to do a
 conversion first).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_cmp_ld (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_cmp_si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 723
 ret = mpfr_cmp_si (op1, op2)

 Compare OP1 and OP2.  Return a positive value if OP1 > OP2, zero if
 OP1 = OP2, and a negative value if OP1 < OP2.  Both OP1 and OP2 are
 considered to their full own precision, which may differ.  If one
 of the operands is NaN, set the _erange_ flag and return zero.

 Note: These functions may be useful to distinguish the three
 possible cases.  If you need to distinguish two cases only, it is
 recommended to use the predicate functions (e.g., ‘mpfr_equal_p’
 for the equality) described below; they behave like the IEEE 754
 comparisons, in particular when one or both arguments are NaN.  But
 only floating-point numbers can be compared (you may need to do a
 conversion first).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_cmp_si (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_cmp_si_2exp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 115
 ret = mpfr_cmp_si_2exp (op1, op2, e)

 Compare OP1 and OP2 multiplied by two to the power E.  Similar as
 above.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_cmp_si_2exp (op1, op2, e)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_cmp_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 723
 ret = mpfr_cmp_ui (op1, op2)

 Compare OP1 and OP2.  Return a positive value if OP1 > OP2, zero if
 OP1 = OP2, and a negative value if OP1 < OP2.  Both OP1 and OP2 are
 considered to their full own precision, which may differ.  If one
 of the operands is NaN, set the _erange_ flag and return zero.

 Note: These functions may be useful to distinguish the three
 possible cases.  If you need to distinguish two cases only, it is
 recommended to use the predicate functions (e.g., ‘mpfr_equal_p’
 for the equality) described below; they behave like the IEEE 754
 comparisons, in particular when one or both arguments are NaN.  But
 only floating-point numbers can be compared (you may need to do a
 conversion first).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_cmp_ui (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_cmp_ui_2exp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 115
 ret = mpfr_cmp_ui_2exp (op1, op2, e)

 Compare OP1 and OP2 multiplied by two to the power E.  Similar as
 above.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_cmp_ui_2exp (op1, op2, e)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_cmpabs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 236
 ret = mpfr_cmpabs (op1, op2)

 Compare |OP1| and |OP2|.  Return a positive value if |OP1| > |OP2|,
 zero if |OP1| = |OP2|, and a negative value if |OP1| < |OP2|.  If
 one of the operands is NaN, set the _erange_ flag and return zero.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_cmpabs (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_cmpabs_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 239
 ret = mpfr_cmpabs_ui (op1, op2)

 Compare |OP1| and |OP2|.  Return a positive value if |OP1| > |OP2|,
 zero if |OP1| = |OP2|, and a negative value if |OP1| < |OP2|.  If
 one of the operands is NaN, set the _erange_ flag and return zero.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_cmpabs_ui (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
mpfr_const_catalan


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 394
 ret = mpfr_const_catalan (rop, rnd)

 Set ROP to the logarithm of 2, the value of Pi, of Euler’s constant
 0.577..., of Catalan’s constant 0.915..., respectively, rounded in
 the direction RND.  These functions cache the computed values to
 avoid other calculations if a lower or equal precision is
 requested.  To free these caches, use ‘mpfr_free_cache’ or
 ‘mpfr_free_cache2’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_const_catalan (rop, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_const_euler


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 392
 ret = mpfr_const_euler (rop, rnd)

 Set ROP to the logarithm of 2, the value of Pi, of Euler’s constant
 0.577..., of Catalan’s constant 0.915..., respectively, rounded in
 the direction RND.  These functions cache the computed values to
 avoid other calculations if a lower or equal precision is
 requested.  To free these caches, use ‘mpfr_free_cache’ or
 ‘mpfr_free_cache2’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_const_euler (rop, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_const_log2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 391
 ret = mpfr_const_log2 (rop, rnd)

 Set ROP to the logarithm of 2, the value of Pi, of Euler’s constant
 0.577..., of Catalan’s constant 0.915..., respectively, rounded in
 the direction RND.  These functions cache the computed values to
 avoid other calculations if a lower or equal precision is
 requested.  To free these caches, use ‘mpfr_free_cache’ or
 ‘mpfr_free_cache2’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_const_log2 (rop, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_const_pi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 389
 ret = mpfr_const_pi (rop, rnd)

 Set ROP to the logarithm of 2, the value of Pi, of Euler’s constant
 0.577..., of Catalan’s constant 0.915..., respectively, rounded in
 the direction RND.  These functions cache the computed values to
 avoid other calculations if a lower or equal precision is
 requested.  To free these caches, use ‘mpfr_free_cache’ or
 ‘mpfr_free_cache2’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_const_pi (rop, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_copysign


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 277
 ret = mpfr_copysign (rop, op1, op2, 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).  This function is equivalent to ‘mpfr_setsign (ROP, OP1,
 mpfr_signbit (OP2), RND)’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_copysign (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_cos


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 121
 ret = mpfr_cos (rop, op, rnd)

 Set ROP to the cosine of OP, sine of OP, tangent of OP, rounded in
 the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_cos (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_cosh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 123
 ret = mpfr_cosh (rop, op, rnd)

 Set ROP to the hyperbolic cosine, sine or tangent of OP, rounded in
 the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_cosh (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_cot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 127
 ret = mpfr_cot (rop, op, rnd)

 Set ROP to the secant of OP, cosecant of OP, cotangent of OP,
 rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_cot (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_coth


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 139
 ret = mpfr_coth (rop, op, rnd)

 Set ROP to the hyperbolic secant of OP, cosecant of OP, cotangent
 of OP, rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_coth (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_csc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 127
 ret = mpfr_csc (rop, op, rnd)

 Set ROP to the secant of OP, cosecant of OP, cotangent of OP,
 rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_csc (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_csch


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 139
 ret = mpfr_csch (rop, op, rnd)

 Set ROP to the hyperbolic secant of OP, cosecant of OP, cotangent
 of OP, rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_csch (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_d_div


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 504
 ret = mpfr_d_div (rop, op1, op2, rnd)

 Set ROP to OP1/OP2 rounded in the direction RND.  When a result is
 zero, its sign is the product of the signs of the operands.  For
 types having no signed zeros, 0 is considered positive; but note
 that if OP1 is non-zero and OP2 is zero, the result might change
 from ±Inf to NaN in future MPFR versions if there is an opposite
 decision on the IEEE 754 side.  The same restrictions than for
 ‘mpfr_add_d’ apply to ‘mpfr_d_div’ and ‘mpfr_div_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_d_div (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_d_sub


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 416
 ret = mpfr_d_sub (rop, op1, op2, rnd)

 Set ROP to OP1 - OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) − 0 =
 (+0), (−0) − 0 = (−0), 0 − (+0) = (−0) and 0 − (−0) = (+0)).  The
 same restrictions than for ‘mpfr_add_d’ apply to ‘mpfr_d_sub’ and
 ‘mpfr_sub_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_d_sub (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_digamma


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 198
 ret = mpfr_digamma (rop, op, rnd)

 Set ROP to the value of the Digamma (sometimes also called Psi)
 function on OP, rounded in the direction RND.  When OP is a
 negative integer, set ROP to NaN.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_digamma (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_dim


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 200
 ret = mpfr_dim (rop, op1, op2, 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.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_dim (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_div


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 502
 ret = mpfr_div (rop, op1, op2, rnd)

 Set ROP to OP1/OP2 rounded in the direction RND.  When a result is
 zero, its sign is the product of the signs of the operands.  For
 types having no signed zeros, 0 is considered positive; but note
 that if OP1 is non-zero and OP2 is zero, the result might change
 from ±Inf to NaN in future MPFR versions if there is an opposite
 decision on the IEEE 754 side.  The same restrictions than for
 ‘mpfr_add_d’ apply to ‘mpfr_d_div’ and ‘mpfr_div_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_div (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_div_2si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 186
 ret = mpfr_div_2si (rop, op1, op2, rnd)

 Set ROP to OP1 divided by 2 raised to OP2 rounded in the direction
 RND.  Just decreases the exponent by OP2 when ROP and OP1 are
 identical.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
 ret = mpfr_div_2si (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_div_2ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 186
 ret = mpfr_div_2ui (rop, op1, op2, rnd)

 Set ROP to OP1 divided by 2 raised to OP2 rounded in the direction
 RND.  Just decreases the exponent by OP2 when ROP and OP1 are
 identical.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
 ret = mpfr_div_2ui (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_div_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 504
 ret = mpfr_div_d (rop, op1, op2, rnd)

 Set ROP to OP1/OP2 rounded in the direction RND.  When a result is
 zero, its sign is the product of the signs of the operands.  For
 types having no signed zeros, 0 is considered positive; but note
 that if OP1 is non-zero and OP2 is zero, the result might change
 from ±Inf to NaN in future MPFR versions if there is an opposite
 decision on the IEEE 754 side.  The same restrictions than for
 ‘mpfr_add_d’ apply to ‘mpfr_d_div’ and ‘mpfr_div_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_div_d (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_div_si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 505
 ret = mpfr_div_si (rop, op1, op2, rnd)

 Set ROP to OP1/OP2 rounded in the direction RND.  When a result is
 zero, its sign is the product of the signs of the operands.  For
 types having no signed zeros, 0 is considered positive; but note
 that if OP1 is non-zero and OP2 is zero, the result might change
 from ±Inf to NaN in future MPFR versions if there is an opposite
 decision on the IEEE 754 side.  The same restrictions than for
 ‘mpfr_add_d’ apply to ‘mpfr_d_div’ and ‘mpfr_div_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_div_si (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_div_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 505
 ret = mpfr_div_ui (rop, op1, op2, rnd)

 Set ROP to OP1/OP2 rounded in the direction RND.  When a result is
 zero, its sign is the product of the signs of the operands.  For
 types having no signed zeros, 0 is considered positive; but note
 that if OP1 is non-zero and OP2 is zero, the result might change
 from ±Inf to NaN in future MPFR versions if there is an opposite
 decision on the IEEE 754 side.  The same restrictions than for
 ‘mpfr_add_d’ apply to ‘mpfr_d_div’ and ‘mpfr_div_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_div_ui (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_divby0_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 165
 ret = mpfr_divby0_p ()

 Return the corresponding (underflow, overflow, divide-by-zero,
 invalid, inexact, _erange_) flag, which is non-zero iff the flag is
 set.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 ret = mpfr_divby0_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_dot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 342
 ret = mpfr_dot (rop, a, b, n, rnd)

 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.  Warning:
 for efficiency reasons, A and B are arrays of pointers to ‘mpfr_t’.
 This function is experimental, and does not yet handle intermediate
 overflows and underflows.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
 ret = mpfr_dot (rop, a, b, n, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_eint


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 576
 ret = mpfr_eint (rop, op, rnd)

 Set ROP to the exponential integral of OP, rounded in the direction
 RND.  This is the sum of Euler’s constant, of the logarithm of the
 absolute value of OP, and of the sum for k from 1 to infinity of OP
 to the power k, divided by k and factorial(k).  For positive OP, it
 corresponds to the Ei function at OP (see formula 5.1.10 from the
 Handbook of Mathematical Functions from Abramowitz and Stegun), and
 for negative OP, to the opposite of the E1 function (sometimes
 called eint1) at −OP (formula 5.1.1 from the same reference).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_eint (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_equal_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 206
 ret = mpfr_equal_p (op1, op2)

 Return non-zero if OP1 > OP2, OP1 >= OP2, OP1 < OP2, OP1 <= OP2,
 OP1 = OP2 respectively, and zero otherwise.  Those functions return
 zero whenever OP1 and/or OP2 is NaN.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_equal_p (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_erangeflag_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 169
 ret = mpfr_erangeflag_p ()

 Return the corresponding (underflow, overflow, divide-by-zero,
 invalid, inexact, _erange_) flag, which is non-zero iff the flag is
 set.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 ret = mpfr_erangeflag_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_erf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 161
 ret = mpfr_erf (rop, op, rnd)

 Set ROP to the value of the error function on OP (resp. the
 complementary error function on OP) rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_erf (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_erfc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 162
 ret = mpfr_erfc (rop, op, rnd)

 Set ROP to the value of the error function on OP (resp. the
 complementary error function on OP) rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_erfc (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_exp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 152
 ret = mpfr_exp (rop, op, rnd)

 Set ROP to the exponential of OP, to 2 power of OP or to 10 power
 of OP, respectively, rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_exp (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_exp10


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 154
 ret = mpfr_exp10 (rop, op, rnd)

 Set ROP to the exponential of OP, to 2 power of OP or to 10 power
 of OP, respectively, rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_exp10 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_exp2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 153
 ret = mpfr_exp2 (rop, op, rnd)

 Set ROP to the exponential of OP, to 2 power of OP or to 10 power
 of OP, respectively, rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_exp2 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_expm1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 134
 ret = mpfr_expm1 (rop, op, rnd)

 Set ROP to the exponential of OP followed by a subtraction by one,
 rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_expm1 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_fac_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 99
 ret = mpfr_fac_ui (rop, op, rnd)

 Set ROP to the factorial of OP, rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_fac_ui (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
mpfr_fits_intmax_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 868
 ret = mpfr_fits_intmax_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long’, ‘long’, ‘unsigned int’, ‘int’,
 ‘unsigned short’, ‘short’, ‘uintmax_t’, ‘intmax_t’, when rounded to
 an integer in the direction RND.  For instance, with the
 ‘MPFR_RNDU’ rounding mode on −0.5, the result will be non-zero for
 all these functions.  For ‘MPFR_RNDF’, those functions return
 non-zero when it is guaranteed that the corresponding conversion
 function (for example ‘mpfr_get_ui’ for ‘mpfr_fits_ulong_p’), when
 called with faithful rounding, will always return a number that is
 representable in the corresponding type.  As a consequence, for
 ‘MPFR_RNDF’, ‘mpfr_fits_ulong_p’ will return non-zero for a
 non-negative number less than or equal to ‘ULONG_MAX’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
 ret = mpfr_fits_intmax_p (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_fits_sint_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 866
 ret = mpfr_fits_sint_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long’, ‘long’, ‘unsigned int’, ‘int’,
 ‘unsigned short’, ‘short’, ‘uintmax_t’, ‘intmax_t’, when rounded to
 an integer in the direction RND.  For instance, with the
 ‘MPFR_RNDU’ rounding mode on −0.5, the result will be non-zero for
 all these functions.  For ‘MPFR_RNDF’, those functions return
 non-zero when it is guaranteed that the corresponding conversion
 function (for example ‘mpfr_get_ui’ for ‘mpfr_fits_ulong_p’), when
 called with faithful rounding, will always return a number that is
 representable in the corresponding type.  As a consequence, for
 ‘MPFR_RNDF’, ‘mpfr_fits_ulong_p’ will return non-zero for a
 non-negative number less than or equal to ‘ULONG_MAX’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_fits_sint_p (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_fits_slong_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 867
 ret = mpfr_fits_slong_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long’, ‘long’, ‘unsigned int’, ‘int’,
 ‘unsigned short’, ‘short’, ‘uintmax_t’, ‘intmax_t’, when rounded to
 an integer in the direction RND.  For instance, with the
 ‘MPFR_RNDU’ rounding mode on −0.5, the result will be non-zero for
 all these functions.  For ‘MPFR_RNDF’, those functions return
 non-zero when it is guaranteed that the corresponding conversion
 function (for example ‘mpfr_get_ui’ for ‘mpfr_fits_ulong_p’), when
 called with faithful rounding, will always return a number that is
 representable in the corresponding type.  As a consequence, for
 ‘MPFR_RNDF’, ‘mpfr_fits_ulong_p’ will return non-zero for a
 non-negative number less than or equal to ‘ULONG_MAX’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_fits_slong_p (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
mpfr_fits_sshort_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 868
 ret = mpfr_fits_sshort_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long’, ‘long’, ‘unsigned int’, ‘int’,
 ‘unsigned short’, ‘short’, ‘uintmax_t’, ‘intmax_t’, when rounded to
 an integer in the direction RND.  For instance, with the
 ‘MPFR_RNDU’ rounding mode on −0.5, the result will be non-zero for
 all these functions.  For ‘MPFR_RNDF’, those functions return
 non-zero when it is guaranteed that the corresponding conversion
 function (for example ‘mpfr_get_ui’ for ‘mpfr_fits_ulong_p’), when
 called with faithful rounding, will always return a number that is
 representable in the corresponding type.  As a consequence, for
 ‘MPFR_RNDF’, ‘mpfr_fits_ulong_p’ will return non-zero for a
 non-negative number less than or equal to ‘ULONG_MAX’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
 ret = mpfr_fits_sshort_p (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_fits_uint_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 866
 ret = mpfr_fits_uint_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long’, ‘long’, ‘unsigned int’, ‘int’,
 ‘unsigned short’, ‘short’, ‘uintmax_t’, ‘intmax_t’, when rounded to
 an integer in the direction RND.  For instance, with the
 ‘MPFR_RNDU’ rounding mode on −0.5, the result will be non-zero for
 all these functions.  For ‘MPFR_RNDF’, those functions return
 non-zero when it is guaranteed that the corresponding conversion
 function (for example ‘mpfr_get_ui’ for ‘mpfr_fits_ulong_p’), when
 called with faithful rounding, will always return a number that is
 representable in the corresponding type.  As a consequence, for
 ‘MPFR_RNDF’, ‘mpfr_fits_ulong_p’ will return non-zero for a
 non-negative number less than or equal to ‘ULONG_MAX’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_fits_uint_p (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
mpfr_fits_uintmax_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 869
 ret = mpfr_fits_uintmax_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long’, ‘long’, ‘unsigned int’, ‘int’,
 ‘unsigned short’, ‘short’, ‘uintmax_t’, ‘intmax_t’, when rounded to
 an integer in the direction RND.  For instance, with the
 ‘MPFR_RNDU’ rounding mode on −0.5, the result will be non-zero for
 all these functions.  For ‘MPFR_RNDF’, those functions return
 non-zero when it is guaranteed that the corresponding conversion
 function (for example ‘mpfr_get_ui’ for ‘mpfr_fits_ulong_p’), when
 called with faithful rounding, will always return a number that is
 representable in the corresponding type.  As a consequence, for
 ‘MPFR_RNDF’, ‘mpfr_fits_ulong_p’ will return non-zero for a
 non-negative number less than or equal to ‘ULONG_MAX’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_fits_uintmax_p (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_fits_ulong_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 867
 ret = mpfr_fits_ulong_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long’, ‘long’, ‘unsigned int’, ‘int’,
 ‘unsigned short’, ‘short’, ‘uintmax_t’, ‘intmax_t’, when rounded to
 an integer in the direction RND.  For instance, with the
 ‘MPFR_RNDU’ rounding mode on −0.5, the result will be non-zero for
 all these functions.  For ‘MPFR_RNDF’, those functions return
 non-zero when it is guaranteed that the corresponding conversion
 function (for example ‘mpfr_get_ui’ for ‘mpfr_fits_ulong_p’), when
 called with faithful rounding, will always return a number that is
 representable in the corresponding type.  As a consequence, for
 ‘MPFR_RNDF’, ‘mpfr_fits_ulong_p’ will return non-zero for a
 non-negative number less than or equal to ‘ULONG_MAX’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_fits_ulong_p (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
mpfr_fits_ushort_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 868
 ret = mpfr_fits_ushort_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long’, ‘long’, ‘unsigned int’, ‘int’,
 ‘unsigned short’, ‘short’, ‘uintmax_t’, ‘intmax_t’, when rounded to
 an integer in the direction RND.  For instance, with the
 ‘MPFR_RNDU’ rounding mode on −0.5, the result will be non-zero for
 all these functions.  For ‘MPFR_RNDF’, those functions return
 non-zero when it is guaranteed that the corresponding conversion
 function (for example ‘mpfr_get_ui’ for ‘mpfr_fits_ulong_p’), when
 called with faithful rounding, will always return a number that is
 representable in the corresponding type.  As a consequence, for
 ‘MPFR_RNDF’, ‘mpfr_fits_ulong_p’ will return non-zero for a
 non-negative number less than or equal to ‘ULONG_MAX’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
 ret = mpfr_fits_ushort_p (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_floor


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1855
 ret = mpfr_floor (rop, op)

 Set ROP to OP rounded to an integer.  ‘mpfr_rint’ rounds to the
 nearest representable integer in the given direction RND, and the
 other five functions behave in a similar way with some fixed
 rounding mode:
 • ‘mpfr_ceil’: to the next higher or equal representable integer
 • ‘mpfr_floor’ to the next lower or equal representable integer
 • ‘mpfr_round’ to the nearest representable integer, rounding
 • ‘mpfr_roundeven’ to the nearest representable integer,
 • ‘mpfr_trunc’ to the next representable integer toward zero
 When OP is a zero or an infinity, set ROP to the same value (with
 the same sign).

 The return value is zero when the result is exact, positive when it
 is greater than the original value of OP, and negative when it is
 smaller.  More precisely, the return value is 0 when OP is an
 integer representable in ROP, 1 or −1 when OP is an integer that is
 not representable in ROP, 2 or −2 when OP is not an integer.

 When OP is NaN, the NaN flag is set as usual.  In the other cases,
 the inexact flag is set when ROP differs from OP, following the ISO
 C99 rule for the ‘rint’ function.  If you want the behavior to be
 more like IEEE 754 / ISO TS 18661-1, i.e., the usual behavior where
 the round-to-integer function is regarded as any other mathematical
 function, you should use one the ‘mpfr_rint_*’ functions instead.

 Note that no double rounding is performed; for instance, 10.5
 (1010.1 in binary) is rounded by ‘mpfr_rint’ with rounding to
 nearest to 12 (1100 in binary) in 2-bit precision, because the two
 enclosing numbers representable on two bits are 8 and 12, and the
 closest is 12.  (If one first rounded to an integer, one would
 round 10.5 to 10 with even rounding, and then 10 would be rounded
 to 8 again with even rounding.)




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 ret = mpfr_floor (rop, op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_fma


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 351
 ret = mpfr_fma (rop, op1, op2, op3, rnd)

 Set ROP to (OP1 times OP2) + OP3 (resp. (OP1 times OP2) - OP3)
 rounded in the direction RND.  Concerning special values (signed
 zeros, infinities, NaN), these functions behave like a
 multiplication followed by a separate addition or subtraction.
 That is, the fused operation matters only for rounding.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_fma (rop, op1, op2, op3, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_fmma


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 370
 ret = mpfr_fmma (rop, op1, op2, op3, op4, rnd)

 Set ROP to (OP1 times OP2) + (OP3 times OP4) (resp. (OP1 times OP2)
 - (OP3 times OP4)) rounded in the direction RND.  In case the
 computation of OP1 times OP2 overflows or underflows (or that of
 OP3 times OP4), the result ROP is computed as if the two
 intermediate products were computed with rounding toward zero.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
 ret = mpfr_fmma (rop, op1, op2, op3, op4, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_fmms


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 370
 ret = mpfr_fmms (rop, op1, op2, op3, op4, rnd)

 Set ROP to (OP1 times OP2) + (OP3 times OP4) (resp. (OP1 times OP2)
 - (OP3 times OP4)) rounded in the direction RND.  In case the
 computation of OP1 times OP2 overflows or underflows (or that of
 OP3 times OP4), the result ROP is computed as if the two
 intermediate products were computed with rounding toward zero.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
 ret = mpfr_fmms (rop, op1, op2, op3, op4, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_fmod


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1157
 ret = mpfr_fmod (r, x, y, rnd)

 Set R to the value of X - NY, rounded according to the direction
 RND, where N is the integer quotient of X divided by Y, defined as
 follows: N is rounded toward zero for ‘mpfr_fmod’ and
 ‘mpfr_fmodquo’, and to the nearest integer (ties rounded to even)
 for ‘mpfr_remainder’ and ‘mpfr_remquo’.

 Special values are handled as described in Section F.9.7.1 of the
 ISO C99 standard: If X is infinite or Y is zero, R is NaN.  If Y is
 infinite and X is finite, R is X rounded to the precision of R.  If
 R is zero, it has the sign of X.  The return value is the ternary
 value corresponding to R.

 Additionally, ‘mpfr_fmodquo’ and ‘mpfr_remquo’ store the low
 significant bits from the quotient N in *Q (more precisely the
 number of bits in a ‘long’ minus one), with the sign of X divided
 by Y (except if those low bits are all zero, in which case zero is
 returned).  Note that X may be so large in magnitude relative to Y
 that an exact representation of the quotient is not practical.  The
 ‘mpfr_remainder’ and ‘mpfr_remquo’ functions are useful for
 additive argument reduction.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_fmod (r, x, y, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_fmodquo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1165
 [ret, q] = mpfr_fmodquo (r, x, y, rnd)

 Set R to the value of X - NY, rounded according to the direction
 RND, where N is the integer quotient of X divided by Y, defined as
 follows: N is rounded toward zero for ‘mpfr_fmod’ and
 ‘mpfr_fmodquo’, and to the nearest integer (ties rounded to even)
 for ‘mpfr_remainder’ and ‘mpfr_remquo’.

 Special values are handled as described in Section F.9.7.1 of the
 ISO C99 standard: If X is infinite or Y is zero, R is NaN.  If Y is
 infinite and X is finite, R is X rounded to the precision of R.  If
 R is zero, it has the sign of X.  The return value is the ternary
 value corresponding to R.

 Additionally, ‘mpfr_fmodquo’ and ‘mpfr_remquo’ store the low
 significant bits from the quotient N in *Q (more precisely the
 number of bits in a ‘long’ minus one), with the sign of X divided
 by Y (except if those low bits are all zero, in which case zero is
 returned).  Note that X may be so large in magnitude relative to Y
 that an exact representation of the quotient is not practical.  The
 ‘mpfr_remainder’ and ‘mpfr_remquo’ functions are useful for
 additive argument reduction.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 [ret, q] = mpfr_fmodquo (r, x, y, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_fms


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 351
 ret = mpfr_fms (rop, op1, op2, op3, rnd)

 Set ROP to (OP1 times OP2) + OP3 (resp. (OP1 times OP2) - OP3)
 rounded in the direction RND.  Concerning special values (signed
 zeros, infinities, NaN), these functions behave like a
 multiplication followed by a separate addition or subtraction.
 That is, the fused operation matters only for rounding.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_fms (rop, op1, op2, op3, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_frac


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 345
 ret = mpfr_frac (rop, op, rnd)

 Set ROP to the fractional part of OP, having the same sign as OP,
 rounded in the direction RND (unlike in ‘mpfr_rint’, RND affects
 only how the exact fractional part is rounded, not how the
 fractional part is generated).  When OP is an integer or an
 infinity, set ROP to zero with the same sign as OP.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_frac (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_free_str


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 227
 mpfr_free_str (varargin)

 This function does nothing (NOP)!

 Free a string allocated by ‘mpfr_get_str’ using the unallocation
 function (*note Memory Handling::).  The block is assumed to be
 ‘strlen(STR)+1’ bytes.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
 mpfr_free_str (varargin)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_frexp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 380
 ret = mpfr_frexp (exp, y, x, rnd)

 Set EXP (formally, the value pointed to by EXP) and Y such that
 0.5<=abs(Y)<1 and Y times 2 raised to EXP equals X rounded to the
 precision of Y, using the given rounding mode.  If X is zero, then
 Y is set to a zero of the same sign and EXP is set to 0.  If X is
 NaN or an infinity, then Y is set to the same value and EXP is
 undefined.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_frexp (exp, y, x, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_gamma


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 585
 ret = mpfr_gamma (rop, op, rnd)

 Set ROP to the value of the Gamma function on OP, resp.  the
 incomplete Gamma function on OP and OP2, rounded in the direction
 RND.  (In the literature, ‘mpfr_gamma_inc’ is called upper
 incomplete Gamma function, or sometimes complementary incomplete
 Gamma function.)  For ‘mpfr_gamma’ (and ‘mpfr_gamma_inc’ when OP2
 is zero), when OP is a negative integer, ROP is set to NaN.

 Note: the current implementation of ‘mpfr_gamma_inc’ is slow for
 large values of ROP or OP, in which case some internal overflow
 might also occur.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_gamma (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_gamma_inc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 594
 ret = mpfr_gamma_inc (rop, op, op2, rnd)

 Set ROP to the value of the Gamma function on OP, resp.  the
 incomplete Gamma function on OP and OP2, rounded in the direction
 RND.  (In the literature, ‘mpfr_gamma_inc’ is called upper
 incomplete Gamma function, or sometimes complementary incomplete
 Gamma function.)  For ‘mpfr_gamma’ (and ‘mpfr_gamma_inc’ when OP2
 is zero), when OP is a negative integer, ROP is set to NaN.

 Note: the current implementation of ‘mpfr_gamma_inc’ is slow for
 large values of ROP or OP, in which case some internal overflow
 might also occur.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_gamma_inc (rop, op, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_get_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 706
 ret = mpfr_get_d (op, rnd)

 Convert OP to a ‘float’ (respectively ‘double’, ‘long double’,
 ‘_Decimal64’, or ‘_Decimal128’) using the rounding mode RND.  If OP
 is NaN, some fixed NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned.  If OP is ±Inf, an infinity of the same sign
 or the result of ±1.0/0.0 is returned.  If OP is zero, these
 functions return a zero, trying to preserve its sign, if possible.
 The ‘mpfr_get_float128’, ‘mpfr_get_decimal64’ and
 ‘mpfr_get_decimal128’ functions are built only under some
 conditions: see the documentation of ‘mpfr_set_float128’,
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ respectively.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 ret = mpfr_get_d (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_get_d_2exp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 543
 ret = mpfr_get_d_2exp (exp, op, rnd)

 Return D and set EXP (formally, the value pointed to by EXP) such
 that 0.5<=abs(D)<1 and D times 2 raised to EXP equals OP rounded to
 double (resp. long double) precision, using the given rounding
 mode.  If OP is zero, then a zero of the same sign (or an unsigned
 zero, if the implementation does not have signed zeros) is
 returned, and EXP is set to 0.  If OP is NaN or an infinity, then
 the corresponding double precision (resp. long-double precision)
 value is returned, and EXP is undefined.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_get_d_2exp (exp, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
mpfr_get_decimal128


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 715
 ret = mpfr_get_decimal128 (op, rnd)

 Convert OP to a ‘float’ (respectively ‘double’, ‘long double’,
 ‘_Decimal64’, or ‘_Decimal128’) using the rounding mode RND.  If OP
 is NaN, some fixed NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned.  If OP is ±Inf, an infinity of the same sign
 or the result of ±1.0/0.0 is returned.  If OP is zero, these
 functions return a zero, trying to preserve its sign, if possible.
 The ‘mpfr_get_float128’, ‘mpfr_get_decimal64’ and
 ‘mpfr_get_decimal128’ functions are built only under some
 conditions: see the documentation of ‘mpfr_set_float128’,
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ respectively.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_get_decimal128 (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
mpfr_get_decimal64


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 714
 ret = mpfr_get_decimal64 (op, rnd)

 Convert OP to a ‘float’ (respectively ‘double’, ‘long double’,
 ‘_Decimal64’, or ‘_Decimal128’) using the rounding mode RND.  If OP
 is NaN, some fixed NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned.  If OP is ±Inf, an infinity of the same sign
 or the result of ±1.0/0.0 is returned.  If OP is zero, these
 functions return a zero, trying to preserve its sign, if possible.
 The ‘mpfr_get_float128’, ‘mpfr_get_decimal64’ and
 ‘mpfr_get_decimal128’ functions are built only under some
 conditions: see the documentation of ‘mpfr_set_float128’,
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ respectively.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
 ret = mpfr_get_decimal64 (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
mpfr_get_default_prec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 142
 ret = mpfr_get_default_prec ()

 Return the current default MPFR precision in bits.  See the
 documentation of ‘mpfr_set_default_prec’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_get_default_prec ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
mpfr_get_default_rounding_mode


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
 ret = mpfr_get_default_rounding_mode ()

 Get the default rounding mode.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
 ret = mpfr_get_default_rounding_mode ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_get_emax


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 389
 ret = mpfr_get_emax ()

 Return the (current) smallest and largest exponents allowed for a
 floating-point variable.  The smallest positive value of a
 floating-point variable is one half times 2 raised to the smallest
 exponent and the largest value has the form (1 - epsilon) times 2
 raised to the largest exponent, where epsilon depends on the
 precision of the considered variable.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 ret = mpfr_get_emax ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_get_emax_max


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 324
 ret = mpfr_get_emax_max ()

 Return the minimum and maximum of the exponents allowed for
 ‘mpfr_set_emin’ and ‘mpfr_set_emax’ respectively.  These values are
 implementation dependent, thus a program using
 ‘mpfr_set_emax(mpfr_get_emax_max())’ or
 ‘mpfr_set_emin(mpfr_get_emin_min())’ may not be portable.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 ret = mpfr_get_emax_max ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_get_emax_min


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 324
 ret = mpfr_get_emax_min ()

 Return the minimum and maximum of the exponents allowed for
 ‘mpfr_set_emin’ and ‘mpfr_set_emax’ respectively.  These values are
 implementation dependent, thus a program using
 ‘mpfr_set_emax(mpfr_get_emax_max())’ or
 ‘mpfr_set_emin(mpfr_get_emin_min())’ may not be portable.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 ret = mpfr_get_emax_min ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_get_emin


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 389
 ret = mpfr_get_emin ()

 Return the (current) smallest and largest exponents allowed for a
 floating-point variable.  The smallest positive value of a
 floating-point variable is one half times 2 raised to the smallest
 exponent and the largest value has the form (1 - epsilon) times 2
 raised to the largest exponent, where epsilon depends on the
 precision of the considered variable.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 ret = mpfr_get_emin ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_get_emin_max


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 324
 ret = mpfr_get_emin_max ()

 Return the minimum and maximum of the exponents allowed for
 ‘mpfr_set_emin’ and ‘mpfr_set_emax’ respectively.  These values are
 implementation dependent, thus a program using
 ‘mpfr_set_emax(mpfr_get_emax_max())’ or
 ‘mpfr_set_emin(mpfr_get_emin_min())’ may not be portable.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 ret = mpfr_get_emin_max ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_get_emin_min


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 324
 ret = mpfr_get_emin_min ()

 Return the minimum and maximum of the exponents allowed for
 ‘mpfr_set_emin’ and ‘mpfr_set_emax’ respectively.  These values are
 implementation dependent, thus a program using
 ‘mpfr_set_emax(mpfr_get_emax_max())’ or
 ‘mpfr_set_emin(mpfr_get_emin_min())’ may not be portable.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 ret = mpfr_get_emin_min ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_get_exp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 293
 ret = mpfr_get_exp (x)

 Return the exponent of X, assuming that X is a non-zero ordinary
 number and the significand is considered in [1/2,1).  For this
 function, X is allowed to be outside of the current range of
 acceptable values.  The behavior for NaN, infinity or zero is
 undefined.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 ret = mpfr_get_exp (x)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_get_float128


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 713
 ret = mpfr_get_float128 (op, rnd)

 Convert OP to a ‘float’ (respectively ‘double’, ‘long double’,
 ‘_Decimal64’, or ‘_Decimal128’) using the rounding mode RND.  If OP
 is NaN, some fixed NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned.  If OP is ±Inf, an infinity of the same sign
 or the result of ±1.0/0.0 is returned.  If OP is zero, these
 functions return a zero, trying to preserve its sign, if possible.
 The ‘mpfr_get_float128’, ‘mpfr_get_decimal64’ and
 ‘mpfr_get_decimal128’ functions are built only under some
 conditions: see the documentation of ‘mpfr_set_float128’,
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ respectively.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_get_float128 (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_get_flt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 708
 ret = mpfr_get_flt (op, rnd)

 Convert OP to a ‘float’ (respectively ‘double’, ‘long double’,
 ‘_Decimal64’, or ‘_Decimal128’) using the rounding mode RND.  If OP
 is NaN, some fixed NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned.  If OP is ±Inf, an infinity of the same sign
 or the result of ±1.0/0.0 is returned.  If OP is zero, these
 functions return a zero, trying to preserve its sign, if possible.
 The ‘mpfr_get_float128’, ‘mpfr_get_decimal64’ and
 ‘mpfr_get_decimal128’ functions are built only under some
 conditions: see the documentation of ‘mpfr_set_float128’,
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ respectively.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_get_flt (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_get_ld


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 707
 ret = mpfr_get_ld (op, rnd)

 Convert OP to a ‘float’ (respectively ‘double’, ‘long double’,
 ‘_Decimal64’, or ‘_Decimal128’) using the rounding mode RND.  If OP
 is NaN, some fixed NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned.  If OP is ±Inf, an infinity of the same sign
 or the result of ±1.0/0.0 is returned.  If OP is zero, these
 functions return a zero, trying to preserve its sign, if possible.
 The ‘mpfr_get_float128’, ‘mpfr_get_decimal64’ and
 ‘mpfr_get_decimal128’ functions are built only under some
 conditions: see the documentation of ‘mpfr_set_float128’,
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ respectively.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
 ret = mpfr_get_ld (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_get_prec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 112
 ret = mpfr_get_prec (x)

 Return the precision of X, i.e., the number of bits used to store
 its significand.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
 ret = mpfr_get_prec (x)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_get_si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 694
 ret = mpfr_get_si (op, rnd)

 Convert OP to a ‘long’, an ‘unsigned long’, an ‘intmax_t’ or an
 ‘uintmax_t’ (respectively) after rounding it to an integer with
 respect to RND.  If OP is NaN, 0 is returned and the _erange_ flag
 is set.  If OP is too big for the return type, the function returns
 the maximum or the minimum of the corresponding C type, depending
 on the direction of the overflow; the _erange_ flag is set too.
 When there is no such range error, if the return value differs from
 OP, i.e., if OP is not an integer, the inexact flag is set.  See
 also ‘mpfr_fits_slong_p’, ‘mpfr_fits_ulong_p’, ‘mpfr_fits_intmax_p’
 and ‘mpfr_fits_uintmax_p’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
 ret = mpfr_get_si (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_get_sj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 694
 ret = mpfr_get_sj (op, rnd)

 Convert OP to a ‘long’, an ‘unsigned long’, an ‘intmax_t’ or an
 ‘uintmax_t’ (respectively) after rounding it to an integer with
 respect to RND.  If OP is NaN, 0 is returned and the _erange_ flag
 is set.  If OP is too big for the return type, the function returns
 the maximum or the minimum of the corresponding C type, depending
 on the direction of the overflow; the _erange_ flag is set too.
 When there is no such range error, if the return value differs from
 OP, i.e., if OP is not an integer, the inexact flag is set.  See
 also ‘mpfr_fits_slong_p’, ‘mpfr_fits_ulong_p’, ‘mpfr_fits_intmax_p’
 and ‘mpfr_fits_uintmax_p’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
 ret = mpfr_get_sj (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_get_str


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3081
 [significant, expptr] = mpfr_get_str (base, n, op, rnd)

 Convert OP to a string of digits in base abs(BASE), with rounding
 in the direction RND, where N is either zero (see below) or the
 number of significant digits output in the string.  The argument
 BASE may vary from 2 to 62 or from −2 to −36; otherwise the
 function does nothing and immediately returns a null pointer.

 For BASE in the range 2 to 36, digits and lower-case letters are
 used; for −2 to −36, digits and upper-case letters are used; for 37
 to 62, digits, upper-case letters, and lower-case letters, in that
 significance order, are used.  Warning!  This implies that for BASE
 > 10, the successor of the digit 9 depends on BASE.  This choice
 has been done for compatibility with GMP’s ‘mpf_get_str’ function.
 Users who wish a more consistent behavior should write a simple
 wrapper.

 If the input is NaN, then the returned string is ‘@NaN@’ and the
 NaN flag is set.  If the input is +Inf (resp. −Inf), then the
 returned string is ‘@Inf@’ (resp. ‘-@Inf@’).

 If the input number is a finite number, the exponent is written
 through the pointer EXPPTR (for input 0, the current minimal
 exponent is written); the type ‘mpfr_exp_t’ is large enough to hold
 the exponent in all cases.

 The generated string is a fraction, with an implicit radix point
 immediately to the left of the first digit.  For example, the
 number −3.1416 would be returned as "−31416" in the string and 1
 written at EXPPTR.  If RND is to nearest, and OP is exactly in the
 middle of two consecutive possible outputs, the one with an even
 significand is chosen, where both significands are considered with
 the exponent of OP.  Note that for an odd base, this may not
 correspond to an even last digit: for example with 2 digits in base
 7, (14) and a half is rounded to (15) which is 12 in decimal, (16)
 and a half is rounded to (20) which is 14 in decimal, and (26) and
 a half is rounded to (26) which is 20 in decimal.

 If N is zero, the number of digits of the significand is taken as
 ‘mpfr_get_str_ndigits(BASE,P)’ where P is the precision of OP
 (*note mpfr_get_str_ndigits::).

 If STR is a null pointer, space for the significand is allocated
 using the allocation function (*note Memory Handling::) and a
 pointer to the string is returned (unless the base is invalid).  To
 free the returned string, you must use ‘mpfr_free_str’.

 If STR is not a null pointer, it should point to a block of storage
 large enough for the significand.  A safe block size (sufficient
 for any value) is ‘max(N + 2, 7)’ if N is not zero; if N is zero,
 replace it by ‘mpfr_get_str_ndigits(BASE,P)’ where P is the
 precision of OP, as mentioned above.  The extra two bytes are for a
 possible minus sign, and for the terminating null character, and
 the value 7 accounts for ‘-@Inf@’ plus the terminating null
 character.  The pointer to the string STR is returned (unless the
 base is invalid).

 Like in usual functions, the inexact flag is set iff the result is
 inexact.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
 [significant, expptr] = mpfr_get_str (base, n, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
mpfr_get_str_ndigits


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 558
 ret = mpfr_get_str_ndigits (b, p)

 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.

 The argument B must be in the range 2 to 62; this is the range of
 bases supported by the ‘mpfr_get_str’ function.  Note that contrary
 to the base argument of this function, negative values are not
 accepted.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_get_str_ndigits (b, p)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_get_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 694
 ret = mpfr_get_ui (op, rnd)

 Convert OP to a ‘long’, an ‘unsigned long’, an ‘intmax_t’ or an
 ‘uintmax_t’ (respectively) after rounding it to an integer with
 respect to RND.  If OP is NaN, 0 is returned and the _erange_ flag
 is set.  If OP is too big for the return type, the function returns
 the maximum or the minimum of the corresponding C type, depending
 on the direction of the overflow; the _erange_ flag is set too.
 When there is no such range error, if the return value differs from
 OP, i.e., if OP is not an integer, the inexact flag is set.  See
 also ‘mpfr_fits_slong_p’, ‘mpfr_fits_ulong_p’, ‘mpfr_fits_intmax_p’
 and ‘mpfr_fits_uintmax_p’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
 ret = mpfr_get_ui (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_get_uj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 694
 ret = mpfr_get_uj (op, rnd)

 Convert OP to a ‘long’, an ‘unsigned long’, an ‘intmax_t’ or an
 ‘uintmax_t’ (respectively) after rounding it to an integer with
 respect to RND.  If OP is NaN, 0 is returned and the _erange_ flag
 is set.  If OP is too big for the return type, the function returns
 the maximum or the minimum of the corresponding C type, depending
 on the direction of the overflow; the _erange_ flag is set too.
 When there is no such range error, if the return value differs from
 OP, i.e., if OP is not an integer, the inexact flag is set.  See
 also ‘mpfr_fits_slong_p’, ‘mpfr_fits_ulong_p’, ‘mpfr_fits_intmax_p’
 and ‘mpfr_fits_uintmax_p’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
 ret = mpfr_get_uj (op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_get_version


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 84
 ret = mpfr_get_version ()

 Return the MPFR version, as a null-terminated string.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
 ret = mpfr_get_version ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_greater_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 208
 ret = mpfr_greater_p (op1, op2)

 Return non-zero if OP1 > OP2, OP1 >= OP2, OP1 < OP2, OP1 <= OP2,
 OP1 = OP2 respectively, and zero otherwise.  Those functions return
 zero whenever OP1 and/or OP2 is NaN.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_greater_p (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
mpfr_greaterequal_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 213
 ret = mpfr_greaterequal_p (op1, op2)

 Return non-zero if OP1 > OP2, OP1 >= OP2, OP1 < OP2, OP1 <= OP2,
 OP1 = OP2 respectively, and zero otherwise.  Those functions return
 zero whenever OP1 and/or OP2 is NaN.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_greaterequal_p (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_hypot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 382
 ret = mpfr_hypot (rop, x, y, rnd)

 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.
 Special values are handled as described in the ISO C99
 (Section F.9.4.3) and IEEE 754-2008 (Section 9.2.1) standards: If X
 or Y is an infinity, then +Inf is returned in ROP, even if the
 other number is NaN.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_hypot (rop, x, y, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_inexflag_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 167
 ret = mpfr_inexflag_p ()

 Return the corresponding (underflow, overflow, divide-by-zero,
 invalid, inexact, _erange_) flag, which is non-zero iff the flag is
 set.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
 ret = mpfr_inexflag_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_inf_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 238
 ret = mpfr_inf_p (op)

 Return non-zero if OP is respectively NaN, an infinity, an ordinary
 number (i.e., neither NaN nor an infinity), zero, or a regular
 number (i.e., neither NaN, nor an infinity nor zero).  Return zero
 otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
 ret = mpfr_inf_p (op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_init


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 337
 mpfr_init (x)

 Initialize X, set its precision to the default precision, and set
 its value to NaN.  The default precision can be changed by a call
 to ‘mpfr_set_default_prec’.

 Warning!  In a given program, some other libraries might change the
 default precision and not restore it.  Thus it is safer to use
 ‘mpfr_init2’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
 mpfr_init (x)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_init2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 746
 mpfr_init2 (x, prec)

 Initialize X, set its precision to be *exactly* PREC bits and its
 value to NaN.  (Warning: the corresponding MPF function initializes
 to zero instead.)

 Normally, a variable should be initialized once only or at least be
 cleared, using ‘mpfr_clear’, between initializations.  To change
 the precision of a variable that has already been initialized, use
 ‘mpfr_set_prec’ or ‘mpfr_prec_round’; note that if the precision is
 decreased, the unused memory will not be freed, so that it may be
 wise to choose a large enough initial precision in order to avoid
 reallocations.  The precision PREC must be an integer between
 ‘MPFR_PREC_MIN’ and ‘MPFR_PREC_MAX’ (otherwise the behavior is
 undefined).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
 mpfr_init2 (x, prec)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_init_set


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 223
 ret = mpfr_init_set (rop, op, rnd)

 Initialize ROP and set its value from OP, rounded in the direction
 RND.  The precision of ROP will be taken from the active default
 precision, as set by ‘mpfr_set_default_prec’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
 ret = mpfr_init_set (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_init_set_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 225
 ret = mpfr_init_set_d (rop, op, rnd)

 Initialize ROP and set its value from OP, rounded in the direction
 RND.  The precision of ROP will be taken from the active default
 precision, as set by ‘mpfr_set_default_prec’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_init_set_d (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_init_set_ld


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 226
 ret = mpfr_init_set_ld (rop, op, rnd)

 Initialize ROP and set its value from OP, rounded in the direction
 RND.  The precision of ROP will be taken from the active default
 precision, as set by ‘mpfr_set_default_prec’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_init_set_ld (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_init_set_si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 226
 ret = mpfr_init_set_si (rop, op, rnd)

 Initialize ROP and set its value from OP, rounded in the direction
 RND.  The precision of ROP will be taken from the active default
 precision, as set by ‘mpfr_set_default_prec’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_init_set_si (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_init_set_str


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 165
 ret = mpfr_init_set_str (x, s, base, rnd)

 Initialize X and set its value from the string S in base BASE,
 rounded in the direction RND.  See ‘mpfr_set_str’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
 ret = mpfr_init_set_str (x, s, base, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_init_set_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 226
 ret = mpfr_init_set_ui (rop, op, rnd)

 Initialize ROP and set its value from OP, rounded in the direction
 RND.  The precision of ROP will be taken from the active default
 precision, as set by ‘mpfr_set_default_prec’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_init_set_ui (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_inits


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 607
 mpfr_inits (varargin)

 This function does nothing (NOP)!

 Initialize all the ‘mpfr_t’ variables of the given ‘va_list’, set
 their precision to the default precision and their value to NaN.
 See ‘mpfr_init’ for more details.  The ‘va_list’ is assumed to be
 composed only of type ‘mpfr_t’ (or equivalently ‘mpfr_ptr’).  It
 begins from X, and ends when it encounters a null pointer (whose
 type must also be ‘mpfr_ptr’).

 Warning!  In a given program, some other libraries might change the
 default precision and not restore it.  Thus it is safer to use
 ‘mpfr_inits2’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
 mpfr_inits (varargin)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_inits2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 475
 mpfr_inits2 (varargin)

 This function does nothing (NOP)!

 Initialize all the ‘mpfr_t’ variables of the given variable
 argument ‘va_list’, set their precision to be *exactly* PREC bits
 and their value to NaN.  See ‘mpfr_init2’ for more details.  The
 ‘va_list’ is assumed to be composed only of type ‘mpfr_t’ (or
 equivalently ‘mpfr_ptr’).  It begins from X, and ends when it
 encounters a null pointer (whose type must also be ‘mpfr_ptr’).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 mpfr_inits2 (varargin)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_integer_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
 ret = mpfr_integer_p (op)

 Return non-zero iff OP is an integer.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
 ret = mpfr_integer_p (op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
mpfr_j0


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 376
 ret = mpfr_j0 (rop, op, rnd)

 Set ROP to the value of the first kind Bessel function of order 0,
 (resp. 1 and N) on OP, rounded in the direction RND.  When OP is
 NaN, ROP is always set to NaN.  When OP is plus or minus Infinity,
 ROP is set to +0.  When OP is zero, and N is not zero, ROP is set
 to +0 or −0 depending on the parity and sign of N, and the sign of
 OP.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_j0 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
mpfr_j1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 376
 ret = mpfr_j1 (rop, op, rnd)

 Set ROP to the value of the first kind Bessel function of order 0,
 (resp. 1 and N) on OP, rounded in the direction RND.  When OP is
 NaN, ROP is always set to NaN.  When OP is plus or minus Infinity,
 ROP is set to +0.  When OP is zero, and N is not zero, ROP is set
 to +0 or −0 depending on the parity and sign of N, and the sign of
 OP.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_j1 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
mpfr_jn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 379
 ret = mpfr_jn (rop, n, op, rnd)

 Set ROP to the value of the first kind Bessel function of order 0,
 (resp. 1 and N) on OP, rounded in the direction RND.  When OP is
 NaN, ROP is always set to NaN.  When OP is plus or minus Infinity,
 ROP is set to +0.  When OP is zero, and N is not zero, ROP is set
 to +0 or −0 depending on the parity and sign of N, and the sign of
 OP.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_jn (rop, n, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_less_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 205
 ret = mpfr_less_p (op1, op2)

 Return non-zero if OP1 > OP2, OP1 >= OP2, OP1 < OP2, OP1 <= OP2,
 OP1 = OP2 respectively, and zero otherwise.  Those functions return
 zero whenever OP1 and/or OP2 is NaN.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_less_p (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_lessequal_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 210
 ret = mpfr_lessequal_p (op1, op2)

 Return non-zero if OP1 > OP2, OP1 >= OP2, OP1 < OP2, OP1 <= OP2,
 OP1 = OP2 respectively, and zero otherwise.  Those functions return
 zero whenever OP1 and/or OP2 is NaN.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_lessequal_p (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
mpfr_lessgreater_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 197
 ret = mpfr_lessgreater_p (op1, op2)

 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).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_lessgreater_p (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_lgamma


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 498
 [ret, signp] = mpfr_lgamma (rop, op, rnd)

 Set ROP to the value of the logarithm of the absolute value of the
 Gamma function on OP, rounded in the direction RND.  The sign (1 or
 −1) of Gamma(OP) is returned in the object pointed to by SIGNP.
 When OP is 1 or 2, set ROP to +0 (in all rounding modes).  When OP
 is an infinity or a nonpositive integer, set ROP to +Inf.  When OP
 is NaN, −Inf or a negative integer, *SIGNP is undefined, and when
 OP is ±0, *SIGNP is the sign of the zero.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
 [ret, signp] = mpfr_lgamma (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_li2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 197
 ret = mpfr_li2 (rop, op, rnd)

 Set ROP to real part of the dilogarithm of OP, rounded in the
 direction RND.  MPFR defines the dilogarithm function as the
 integral of -log(1-t)/t from 0 to OP.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_li2 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_lngamma


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 419
 ret = mpfr_lngamma (rop, op, rnd)

 Set ROP to the value of the logarithm of the Gamma function on OP,
 rounded in the direction RND.  When OP is 1 or 2, set ROP to +0 (in
 all rounding modes).  When OP is an infinity or a nonpositive
 integer, set ROP to +Inf, following the general rules on special
 values.  When −2K−1 < OP < −2K, K being a nonnegative integer, set
 ROP to NaN.  See also ‘mpfr_lgamma’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_lngamma (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_log


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 351
 ret = mpfr_log (rop, op, rnd)

 Set ROP to the natural logarithm of OP, log2(OP) or log10(OP),
 respectively, rounded in the direction RND.  Set ROP to +0 if OP is
 1 (in all rounding modes), for consistency with the ISO C99 and
 IEEE 754-2008 standards.  Set ROP to −Inf if OP is ±0 (i.e., the
 sign of the zero has no influence on the result).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_log (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_log10


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 353
 ret = mpfr_log10 (rop, op, rnd)

 Set ROP to the natural logarithm of OP, log2(OP) or log10(OP),
 respectively, rounded in the direction RND.  Set ROP to +0 if OP is
 1 (in all rounding modes), for consistency with the ISO C99 and
 IEEE 754-2008 standards.  Set ROP to −Inf if OP is ±0 (i.e., the
 sign of the zero has no influence on the result).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_log10 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_log1p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 142
 ret = mpfr_log1p (rop, op, rnd)

 Set ROP to the logarithm of one plus OP, rounded in the direction
 RND.  Set ROP to −Inf if OP is −1.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_log1p (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_log2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 352
 ret = mpfr_log2 (rop, op, rnd)

 Set ROP to the natural logarithm of OP, log2(OP) or log10(OP),
 respectively, rounded in the direction RND.  Set ROP to +0 if OP is
 1 (in all rounding modes), for consistency with the ISO C99 and
 IEEE 754-2008 standards.  Set ROP to −Inf if OP is ±0 (i.e., the
 sign of the zero has no influence on the result).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_log2 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_log_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 354
 ret = mpfr_log_ui (rop, op, rnd)

 Set ROP to the natural logarithm of OP, log2(OP) or log10(OP),
 respectively, rounded in the direction RND.  Set ROP to +0 if OP is
 1 (in all rounding modes), for consistency with the ISO C99 and
 IEEE 754-2008 standards.  Set ROP to −Inf if OP is ±0 (i.e., the
 sign of the zero has no influence on the result).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_log_ui (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_max


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 295
 ret = mpfr_max (rop, op1, op2, rnd)

 Set ROP to the minimum (resp. maximum) of OP1 and OP2.  If OP1 and
 OP2 are both NaN, then ROP is set to NaN.  If OP1 or OP2 is NaN,
 then ROP is set to the numeric value.  If OP1 and OP2 are zeros of
 different signs, then ROP is set to −0 (resp. +0).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_max (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_min


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 295
 ret = mpfr_min (rop, op1, op2, rnd)

 Set ROP to the minimum (resp. maximum) of OP1 and OP2.  If OP1 and
 OP2 are both NaN, then ROP is set to NaN.  If OP1 or OP2 is NaN,
 then ROP is set to the numeric value.  If OP1 and OP2 are zeros of
 different signs, then ROP is set to −0 (resp. +0).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_min (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_min_prec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 142
 ret = mpfr_min_prec (x)

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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
 ret = mpfr_min_prec (x)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_modf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 454
 ret = mpfr_modf (iop, fop, op, rnd)

 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 (equivalent to
 ‘mpfr_trunc(IOP, OP, RND)’ and ‘mpfr_frac(FOP, OP, RND)’).  The
 variables IOP and FOP must be different.  Return 0 iff both results
 are exact (see ‘mpfr_sin_cos’ for a more detailed description of
 the return value).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_modf (iop, fop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_mul


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 314
 ret = mpfr_mul (rop, op1, op2, rnd)

 Set ROP to OP1 times OP2 rounded in the direction RND.  When a
 result is zero, its sign is the product of the signs of the
 operands (for types having no signed zeros, 0 is considered
 positive).  The same restrictions than for ‘mpfr_add_d’ apply to
 ‘mpfr_mul_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_mul (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_mul_2si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 179
 ret = mpfr_mul_2si (rop, op1, op2, rnd)

 Set ROP to OP1 times 2 raised to OP2 rounded in the direction RND.
 Just increases the exponent by OP2 when ROP and OP1 are identical.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
 ret = mpfr_mul_2si (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_mul_2ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 179
 ret = mpfr_mul_2ui (rop, op1, op2, rnd)

 Set ROP to OP1 times 2 raised to OP2 rounded in the direction RND.
 Just increases the exponent by OP2 when ROP and OP1 are identical.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
 ret = mpfr_mul_2ui (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_mul_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 316
 ret = mpfr_mul_d (rop, op1, op2, rnd)

 Set ROP to OP1 times OP2 rounded in the direction RND.  When a
 result is zero, its sign is the product of the signs of the
 operands (for types having no signed zeros, 0 is considered
 positive).  The same restrictions than for ‘mpfr_add_d’ apply to
 ‘mpfr_mul_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_mul_d (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_mul_si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 317
 ret = mpfr_mul_si (rop, op1, op2, rnd)

 Set ROP to OP1 times OP2 rounded in the direction RND.  When a
 result is zero, its sign is the product of the signs of the
 operands (for types having no signed zeros, 0 is considered
 positive).  The same restrictions than for ‘mpfr_add_d’ apply to
 ‘mpfr_mul_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_mul_si (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_mul_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 317
 ret = mpfr_mul_ui (rop, op1, op2, rnd)

 Set ROP to OP1 times OP2 rounded in the direction RND.  When a
 result is zero, its sign is the product of the signs of the
 operands (for types having no signed zeros, 0 is considered
 positive).  The same restrictions than for ‘mpfr_add_d’ apply to
 ‘mpfr_mul_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_mul_ui (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_nan_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 238
 ret = mpfr_nan_p (op)

 Return non-zero if OP is respectively NaN, an infinity, an ordinary
 number (i.e., neither NaN nor an infinity), zero, or a regular
 number (i.e., neither NaN, nor an infinity nor zero).  Return zero
 otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
 ret = mpfr_nan_p (op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_nanflag_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 166
 ret = mpfr_nanflag_p ()

 Return the corresponding (underflow, overflow, divide-by-zero,
 invalid, inexact, _erange_) flag, which is non-zero iff the flag is
 set.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
 ret = mpfr_nanflag_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_neg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 545
 ret = mpfr_neg (rop, op, rnd)

 Set ROP to -OP and the absolute value of OP respectively, rounded
 in the direction RND.  Just changes or adjusts the sign if ROP and
 OP are the same variable, otherwise a rounding might occur if the
 precision of ROP is less than that of OP.

 The sign rule also applies to NaN in order to mimic the IEEE 754
 ‘negate’ and ‘abs’ operations, i.e., for ‘mpfr_neg’, the sign is
 reversed, and for ‘mpfr_abs’, the sign is set to positive.  But
 contrary to IEEE 754, the NaN flag is set as usual.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_neg (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_nextabove


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 109
 mpfr_nextabove (x)

 Equivalent to ‘mpfr_nexttoward’ where Y is plus infinity (resp.
 minus infinity).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
 mpfr_nextabove (x)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_nextbelow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 109
 mpfr_nextbelow (x)

 Equivalent to ‘mpfr_nexttoward’ where Y is plus infinity (resp.
 minus infinity).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
 mpfr_nextbelow (x)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_nexttoward


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 493
 mpfr_nexttoward (x, y)

 If X or Y is NaN, set X to NaN; note that the NaN flag is set as
 usual.  If X and Y are equal, X is unchanged.  Otherwise, if X is
 different from Y, replace X by the next floating-point number (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 same
 sign.  No underflow, overflow, or inexact exception is raised.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 mpfr_nexttoward (x, y)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_number_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 241
 ret = mpfr_number_p (op)

 Return non-zero if OP is respectively NaN, an infinity, an ordinary
 number (i.e., neither NaN nor an infinity), zero, or a regular
 number (i.e., neither NaN, nor an infinity nor zero).  Return zero
 otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
 ret = mpfr_number_p (op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_overflow_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 167
 ret = mpfr_overflow_p ()

 Return the corresponding (underflow, overflow, divide-by-zero,
 invalid, inexact, _erange_) flag, which is non-zero iff the flag is
 set.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
 ret = mpfr_overflow_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_pow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1366
 ret = mpfr_pow (rop, op1, op2, rnd)

 Set ROP to OP1 raised to OP2, rounded in the direction RND.
 Special values are handled as described in the ISO C99 and
 IEEE 754-2008 standards for the ‘pow’ function:
 • ‘pow(±0, Y)’ returns plus or minus infinity for Y a negative
 • ‘pow(±0, Y)’ returns plus infinity for Y negative and not an
 • ‘pow(±0, Y)’ returns plus or minus zero for Y a positive odd
 • ‘pow(±0, Y)’ returns plus zero for Y positive and not an odd
 • ‘pow(-1, ±Inf)’ returns 1.
 • ‘pow(+1, Y)’ returns 1 for any Y, even a NaN.
 • ‘pow(X, ±0)’ returns 1 for any X, even a NaN.
 • ‘pow(X, Y)’ returns NaN for finite negative X and finite
 • ‘pow(X, -Inf)’ returns plus infinity for 0 < abs(x) < 1, and
 • ‘pow(X, +Inf)’ returns plus zero for 0 < abs(x) < 1, and plus
 • ‘pow(-Inf, Y)’ returns minus zero for Y a negative odd
 • ‘pow(-Inf, Y)’ returns plus zero for Y negative and not an odd
 • ‘pow(-Inf, Y)’ returns minus infinity for Y a positive odd
 • ‘pow(-Inf, Y)’ returns plus infinity for Y positive and not an
 • ‘pow(+Inf, Y)’ returns plus zero for Y negative, and plus
 Note: When 0 is of integer type, it is regarded as +0 by these
 functions.  We do not use the usual limit rules in this case, as
 these rules are not used for ‘pow’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_pow (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_pow_si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1369
 ret = mpfr_pow_si (rop, op1, op2, rnd)

 Set ROP to OP1 raised to OP2, rounded in the direction RND.
 Special values are handled as described in the ISO C99 and
 IEEE 754-2008 standards for the ‘pow’ function:
 • ‘pow(±0, Y)’ returns plus or minus infinity for Y a negative
 • ‘pow(±0, Y)’ returns plus infinity for Y negative and not an
 • ‘pow(±0, Y)’ returns plus or minus zero for Y a positive odd
 • ‘pow(±0, Y)’ returns plus zero for Y positive and not an odd
 • ‘pow(-1, ±Inf)’ returns 1.
 • ‘pow(+1, Y)’ returns 1 for any Y, even a NaN.
 • ‘pow(X, ±0)’ returns 1 for any X, even a NaN.
 • ‘pow(X, Y)’ returns NaN for finite negative X and finite
 • ‘pow(X, -Inf)’ returns plus infinity for 0 < abs(x) < 1, and
 • ‘pow(X, +Inf)’ returns plus zero for 0 < abs(x) < 1, and plus
 • ‘pow(-Inf, Y)’ returns minus zero for Y a negative odd
 • ‘pow(-Inf, Y)’ returns plus zero for Y negative and not an odd
 • ‘pow(-Inf, Y)’ returns minus infinity for Y a positive odd
 • ‘pow(-Inf, Y)’ returns plus infinity for Y positive and not an
 • ‘pow(+Inf, Y)’ returns plus zero for Y negative, and plus
 Note: When 0 is of integer type, it is regarded as +0 by these
 functions.  We do not use the usual limit rules in this case, as
 these rules are not used for ‘pow’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_pow_si (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_pow_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1369
 ret = mpfr_pow_ui (rop, op1, op2, rnd)

 Set ROP to OP1 raised to OP2, rounded in the direction RND.
 Special values are handled as described in the ISO C99 and
 IEEE 754-2008 standards for the ‘pow’ function:
 • ‘pow(±0, Y)’ returns plus or minus infinity for Y a negative
 • ‘pow(±0, Y)’ returns plus infinity for Y negative and not an
 • ‘pow(±0, Y)’ returns plus or minus zero for Y a positive odd
 • ‘pow(±0, Y)’ returns plus zero for Y positive and not an odd
 • ‘pow(-1, ±Inf)’ returns 1.
 • ‘pow(+1, Y)’ returns 1 for any Y, even a NaN.
 • ‘pow(X, ±0)’ returns 1 for any X, even a NaN.
 • ‘pow(X, Y)’ returns NaN for finite negative X and finite
 • ‘pow(X, -Inf)’ returns plus infinity for 0 < abs(x) < 1, and
 • ‘pow(X, +Inf)’ returns plus zero for 0 < abs(x) < 1, and plus
 • ‘pow(-Inf, Y)’ returns minus zero for Y a negative odd
 • ‘pow(-Inf, Y)’ returns plus zero for Y negative and not an odd
 • ‘pow(-Inf, Y)’ returns minus infinity for Y a positive odd
 • ‘pow(-Inf, Y)’ returns plus infinity for Y positive and not an
 • ‘pow(+Inf, Y)’ returns plus zero for Y negative, and plus
 Note: When 0 is of integer type, it is regarded as +0 by these
 functions.  We do not use the usual limit rules in this case, as
 these rules are not used for ‘pow’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_pow_ui (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_prec_round


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 867
 ret = mpfr_prec_round (x, prec, 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).  If PREC is greater than or equal to the
 precision of X, then new space is allocated for the significand,
 and it is filled with zeros.  Otherwise, the significand is rounded
 to precision PREC with the given direction; no memory reallocation
 to free the unused limbs is done.  In both cases, the precision of
 X is changed to PREC.

 Here is an example of how to use ‘mpfr_prec_round’ to implement
 Newton’s algorithm to compute the inverse of A, assuming X is
 already an approximation to N bits:

 Warning!  You must not use this function if X was initialized with
 ‘MPFR_DECL_INIT’ or with ‘mpfr_custom_init_set’ (*note Custom
 Interface::).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_prec_round (x, prec, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_rec_sqrt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 374
 ret = mpfr_rec_sqrt (rop, op, rnd)

 Set ROP to the reciprocal square root of OP rounded in the
 direction RND.  Set ROP to +Inf if OP is ±0, +0 if OP is +Inf, and
 NaN if OP is negative.  Warning!  Therefore the result on −0 is
 different from the one of the rSqrt function recommended by the
 IEEE 754-2008 standard (Section 9.2.1), which is −Inf instead of
 +Inf.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
 ret = mpfr_rec_sqrt (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_regular_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 242
 ret = mpfr_regular_p (op)

 Return non-zero if OP is respectively NaN, an infinity, an ordinary
 number (i.e., neither NaN nor an infinity), zero, or a regular
 number (i.e., neither NaN, nor an infinity nor zero).  Return zero
 otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
 ret = mpfr_regular_p (op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_remainder


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1162
 ret = mpfr_remainder (r, x, y, rnd)

 Set R to the value of X - NY, rounded according to the direction
 RND, where N is the integer quotient of X divided by Y, defined as
 follows: N is rounded toward zero for ‘mpfr_fmod’ and
 ‘mpfr_fmodquo’, and to the nearest integer (ties rounded to even)
 for ‘mpfr_remainder’ and ‘mpfr_remquo’.

 Special values are handled as described in Section F.9.7.1 of the
 ISO C99 standard: If X is infinite or Y is zero, R is NaN.  If Y is
 infinite and X is finite, R is X rounded to the precision of R.  If
 R is zero, it has the sign of X.  The return value is the ternary
 value corresponding to R.

 Additionally, ‘mpfr_fmodquo’ and ‘mpfr_remquo’ store the low
 significant bits from the quotient N in *Q (more precisely the
 number of bits in a ‘long’ minus one), with the sign of X divided
 by Y (except if those low bits are all zero, in which case zero is
 returned).  Note that X may be so large in magnitude relative to Y
 that an exact representation of the quotient is not practical.  The
 ‘mpfr_remainder’ and ‘mpfr_remquo’ functions are useful for
 additive argument reduction.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_remainder (r, x, y, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_remquo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1164
 [ret, q] = mpfr_remquo (r, x, y, rnd)

 Set R to the value of X - NY, rounded according to the direction
 RND, where N is the integer quotient of X divided by Y, defined as
 follows: N is rounded toward zero for ‘mpfr_fmod’ and
 ‘mpfr_fmodquo’, and to the nearest integer (ties rounded to even)
 for ‘mpfr_remainder’ and ‘mpfr_remquo’.

 Special values are handled as described in Section F.9.7.1 of the
 ISO C99 standard: If X is infinite or Y is zero, R is NaN.  If Y is
 infinite and X is finite, R is X rounded to the precision of R.  If
 R is zero, it has the sign of X.  The return value is the ternary
 value corresponding to R.

 Additionally, ‘mpfr_fmodquo’ and ‘mpfr_remquo’ store the low
 significant bits from the quotient N in *Q (more precisely the
 number of bits in a ‘long’ minus one), with the sign of X divided
 by Y (except if those low bits are all zero, in which case zero is
 returned).  Note that X may be so large in magnitude relative to Y
 that an exact representation of the quotient is not practical.  The
 ‘mpfr_remainder’ and ‘mpfr_remquo’ functions are useful for
 additive argument reduction.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 [ret, q] = mpfr_remquo (r, x, y, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_rint


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1859
 ret = mpfr_rint (rop, op, rnd)

 Set ROP to OP rounded to an integer.  ‘mpfr_rint’ rounds to the
 nearest representable integer in the given direction RND, and the
 other five functions behave in a similar way with some fixed
 rounding mode:
 • ‘mpfr_ceil’: to the next higher or equal representable integer
 • ‘mpfr_floor’ to the next lower or equal representable integer
 • ‘mpfr_round’ to the nearest representable integer, rounding
 • ‘mpfr_roundeven’ to the nearest representable integer,
 • ‘mpfr_trunc’ to the next representable integer toward zero
 When OP is a zero or an infinity, set ROP to the same value (with
 the same sign).

 The return value is zero when the result is exact, positive when it
 is greater than the original value of OP, and negative when it is
 smaller.  More precisely, the return value is 0 when OP is an
 integer representable in ROP, 1 or −1 when OP is an integer that is
 not representable in ROP, 2 or −2 when OP is not an integer.

 When OP is NaN, the NaN flag is set as usual.  In the other cases,
 the inexact flag is set when ROP differs from OP, following the ISO
 C99 rule for the ‘rint’ function.  If you want the behavior to be
 more like IEEE 754 / ISO TS 18661-1, i.e., the usual behavior where
 the round-to-integer function is regarded as any other mathematical
 function, you should use one the ‘mpfr_rint_*’ functions instead.

 Note that no double rounding is performed; for instance, 10.5
 (1010.1 in binary) is rounded by ‘mpfr_rint’ with rounding to
 nearest to 12 (1100 in binary) in 2-bit precision, because the two
 enclosing numbers representable on two bits are 8 and 12, and the
 closest is 12.  (If one first rounded to an integer, one would
 round 10.5 to 10 with even rounding, and then 10 would be rounded
 to 8 again with even rounding.)




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_rint (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_rint_ceil


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1451
 ret = mpfr_rint_ceil (rop, op, rnd)

 Set ROP to OP rounded to an integer:
 • ‘mpfr_rint_ceil’: to the next higher or equal integer;
 • ‘mpfr_rint_floor’: to the next lower or equal integer;
 • ‘mpfr_rint_round’: to the nearest integer, rounding halfway
 • ‘mpfr_rint_roundeven’: to the nearest integer, rounding
 • ‘mpfr_rint_trunc’ to the next integer toward zero.
 If the result is not representable, it is rounded in the direction
 RND.  When OP is a zero or an infinity, set ROP to the same value
 (with the same sign).  The return value is the ternary value
 associated with the considered round-to-integer function (regarded
 in the same way as any other mathematical function).

 Contrary to ‘mpfr_rint’, those functions do perform a double
 rounding: first OP is rounded to the nearest integer in the
 direction given by the function name, then this nearest integer (if
 not representable) is rounded in the given direction RND.  Thus
 these round-to-integer functions behave more like the other
 mathematical functions, i.e., the returned result is the correct
 rounding of the exact result of the function in the real numbers.

 For example, ‘mpfr_rint_round’ with rounding to nearest and a
 precision of two bits rounds 6.5 to 7 (halfway cases away from
 zero), then 7 is rounded to 8 by the round-even rule, despite the
 fact that 6 is also representable on two bits, and is closer to 6.5
 than 8.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_rint_ceil (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_rint_floor


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1452
 ret = mpfr_rint_floor (rop, op, rnd)

 Set ROP to OP rounded to an integer:
 • ‘mpfr_rint_ceil’: to the next higher or equal integer;
 • ‘mpfr_rint_floor’: to the next lower or equal integer;
 • ‘mpfr_rint_round’: to the nearest integer, rounding halfway
 • ‘mpfr_rint_roundeven’: to the nearest integer, rounding
 • ‘mpfr_rint_trunc’ to the next integer toward zero.
 If the result is not representable, it is rounded in the direction
 RND.  When OP is a zero or an infinity, set ROP to the same value
 (with the same sign).  The return value is the ternary value
 associated with the considered round-to-integer function (regarded
 in the same way as any other mathematical function).

 Contrary to ‘mpfr_rint’, those functions do perform a double
 rounding: first OP is rounded to the nearest integer in the
 direction given by the function name, then this nearest integer (if
 not representable) is rounded in the given direction RND.  Thus
 these round-to-integer functions behave more like the other
 mathematical functions, i.e., the returned result is the correct
 rounding of the exact result of the function in the real numbers.

 For example, ‘mpfr_rint_round’ with rounding to nearest and a
 precision of two bits rounds 6.5 to 7 (halfway cases away from
 zero), then 7 is rounded to 8 by the round-even rule, despite the
 fact that 6 is also representable on two bits, and is closer to 6.5
 than 8.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_rint_floor (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_rint_round


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1452
 ret = mpfr_rint_round (rop, op, rnd)

 Set ROP to OP rounded to an integer:
 • ‘mpfr_rint_ceil’: to the next higher or equal integer;
 • ‘mpfr_rint_floor’: to the next lower or equal integer;
 • ‘mpfr_rint_round’: to the nearest integer, rounding halfway
 • ‘mpfr_rint_roundeven’: to the nearest integer, rounding
 • ‘mpfr_rint_trunc’ to the next integer toward zero.
 If the result is not representable, it is rounded in the direction
 RND.  When OP is a zero or an infinity, set ROP to the same value
 (with the same sign).  The return value is the ternary value
 associated with the considered round-to-integer function (regarded
 in the same way as any other mathematical function).

 Contrary to ‘mpfr_rint’, those functions do perform a double
 rounding: first OP is rounded to the nearest integer in the
 direction given by the function name, then this nearest integer (if
 not representable) is rounded in the given direction RND.  Thus
 these round-to-integer functions behave more like the other
 mathematical functions, i.e., the returned result is the correct
 rounding of the exact result of the function in the real numbers.

 For example, ‘mpfr_rint_round’ with rounding to nearest and a
 precision of two bits rounds 6.5 to 7 (halfway cases away from
 zero), then 7 is rounded to 8 by the round-even rule, despite the
 fact that 6 is also representable on two bits, and is closer to 6.5
 than 8.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_rint_round (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
mpfr_rint_roundeven


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1456
 ret = mpfr_rint_roundeven (rop, op, rnd)

 Set ROP to OP rounded to an integer:
 • ‘mpfr_rint_ceil’: to the next higher or equal integer;
 • ‘mpfr_rint_floor’: to the next lower or equal integer;
 • ‘mpfr_rint_round’: to the nearest integer, rounding halfway
 • ‘mpfr_rint_roundeven’: to the nearest integer, rounding
 • ‘mpfr_rint_trunc’ to the next integer toward zero.
 If the result is not representable, it is rounded in the direction
 RND.  When OP is a zero or an infinity, set ROP to the same value
 (with the same sign).  The return value is the ternary value
 associated with the considered round-to-integer function (regarded
 in the same way as any other mathematical function).

 Contrary to ‘mpfr_rint’, those functions do perform a double
 rounding: first OP is rounded to the nearest integer in the
 direction given by the function name, then this nearest integer (if
 not representable) is rounded in the given direction RND.  Thus
 these round-to-integer functions behave more like the other
 mathematical functions, i.e., the returned result is the correct
 rounding of the exact result of the function in the real numbers.

 For example, ‘mpfr_rint_round’ with rounding to nearest and a
 precision of two bits rounds 6.5 to 7 (halfway cases away from
 zero), then 7 is rounded to 8 by the round-even rule, despite the
 fact that 6 is also representable on two bits, and is closer to 6.5
 than 8.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_rint_roundeven (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_rint_trunc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1452
 ret = mpfr_rint_trunc (rop, op, rnd)

 Set ROP to OP rounded to an integer:
 • ‘mpfr_rint_ceil’: to the next higher or equal integer;
 • ‘mpfr_rint_floor’: to the next lower or equal integer;
 • ‘mpfr_rint_round’: to the nearest integer, rounding halfway
 • ‘mpfr_rint_roundeven’: to the nearest integer, rounding
 • ‘mpfr_rint_trunc’ to the next integer toward zero.
 If the result is not representable, it is rounded in the direction
 RND.  When OP is a zero or an infinity, set ROP to the same value
 (with the same sign).  The return value is the ternary value
 associated with the considered round-to-integer function (regarded
 in the same way as any other mathematical function).

 Contrary to ‘mpfr_rint’, those functions do perform a double
 rounding: first OP is rounded to the nearest integer in the
 direction given by the function name, then this nearest integer (if
 not representable) is rounded in the given direction RND.  Thus
 these round-to-integer functions behave more like the other
 mathematical functions, i.e., the returned result is the correct
 rounding of the exact result of the function in the real numbers.

 For example, ‘mpfr_rint_round’ with rounding to nearest and a
 precision of two bits rounds 6.5 to 7 (halfway cases away from
 zero), then 7 is rounded to 8 by the round-even rule, despite the
 fact that 6 is also representable on two bits, and is closer to 6.5
 than 8.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_rint_trunc (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_root


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 436
 ret = mpfr_root (rop, op, n, rnd)

 This function is the same as ‘mpfr_rootn_ui’ except when OP is −0
 and N is even: the result is −0 instead of +0 (the reason was to be
 consistent with ‘mpfr_sqrt’).  Said otherwise, if OP is zero, set
 ROP to OP.

 This function predates the IEEE 754-2008 standard and behaves
 differently from its rootn function.  It is marked as deprecated
 and will be removed in a future release.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_root (rop, op, n, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_rootn_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 686
 ret = mpfr_rootn_ui (rop, op, n, rnd)

 Set ROP to the Nth root (with N = 3, the cubic root, for
 ‘mpfr_cbrt’) of OP rounded in the direction RND.  For N = 0, set
 ROP to NaN.  For N odd (resp. even) and OP negative (including
 −Inf), set ROP to a negative number (resp. NaN).  If OP is zero,
 set ROP to zero with the sign obtained by the usual limit rules,
 i.e., the same sign as OP if N is odd, and positive if N is even.

 These functions agree with the rootn function of the IEEE 754-2008
 standard and the P754/D2.41 draft of the next standard
 (Section 9.2).  Note that it is here restricted to N >= 0.
 Functions allowing a negative N may be implemented in the future.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_rootn_ui (rop, op, n, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_round


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1855
 ret = mpfr_round (rop, op)

 Set ROP to OP rounded to an integer.  ‘mpfr_rint’ rounds to the
 nearest representable integer in the given direction RND, and the
 other five functions behave in a similar way with some fixed
 rounding mode:
 • ‘mpfr_ceil’: to the next higher or equal representable integer
 • ‘mpfr_floor’ to the next lower or equal representable integer
 • ‘mpfr_round’ to the nearest representable integer, rounding
 • ‘mpfr_roundeven’ to the nearest representable integer,
 • ‘mpfr_trunc’ to the next representable integer toward zero
 When OP is a zero or an infinity, set ROP to the same value (with
 the same sign).

 The return value is zero when the result is exact, positive when it
 is greater than the original value of OP, and negative when it is
 smaller.  More precisely, the return value is 0 when OP is an
 integer representable in ROP, 1 or −1 when OP is an integer that is
 not representable in ROP, 2 or −2 when OP is not an integer.

 When OP is NaN, the NaN flag is set as usual.  In the other cases,
 the inexact flag is set when ROP differs from OP, following the ISO
 C99 rule for the ‘rint’ function.  If you want the behavior to be
 more like IEEE 754 / ISO TS 18661-1, i.e., the usual behavior where
 the round-to-integer function is regarded as any other mathematical
 function, you should use one the ‘mpfr_rint_*’ functions instead.

 Note that no double rounding is performed; for instance, 10.5
 (1010.1 in binary) is rounded by ‘mpfr_rint’ with rounding to
 nearest to 12 (1100 in binary) in 2-bit precision, because the two
 enclosing numbers representable on two bits are 8 and 12, and the
 closest is 12.  (If one first rounded to an integer, one would
 round 10.5 to 10 with even rounding, and then 10 would be rounded
 to 8 again with even rounding.)




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 ret = mpfr_round (rop, op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_roundeven


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1859
 ret = mpfr_roundeven (rop, op)

 Set ROP to OP rounded to an integer.  ‘mpfr_rint’ rounds to the
 nearest representable integer in the given direction RND, and the
 other five functions behave in a similar way with some fixed
 rounding mode:
 • ‘mpfr_ceil’: to the next higher or equal representable integer
 • ‘mpfr_floor’ to the next lower or equal representable integer
 • ‘mpfr_round’ to the nearest representable integer, rounding
 • ‘mpfr_roundeven’ to the nearest representable integer,
 • ‘mpfr_trunc’ to the next representable integer toward zero
 When OP is a zero or an infinity, set ROP to the same value (with
 the same sign).

 The return value is zero when the result is exact, positive when it
 is greater than the original value of OP, and negative when it is
 smaller.  More precisely, the return value is 0 when OP is an
 integer representable in ROP, 1 or −1 when OP is an integer that is
 not representable in ROP, 2 or −2 when OP is not an integer.

 When OP is NaN, the NaN flag is set as usual.  In the other cases,
 the inexact flag is set when ROP differs from OP, following the ISO
 C99 rule for the ‘rint’ function.  If you want the behavior to be
 more like IEEE 754 / ISO TS 18661-1, i.e., the usual behavior where
 the round-to-integer function is regarded as any other mathematical
 function, you should use one the ‘mpfr_rint_*’ functions instead.

 Note that no double rounding is performed; for instance, 10.5
 (1010.1 in binary) is rounded by ‘mpfr_rint’ with rounding to
 nearest to 12 (1100 in binary) in 2-bit precision, because the two
 enclosing numbers representable on two bits are 8 and 12, and the
 closest is 12.  (If one first rounded to an integer, one would
 round 10.5 to 10 with even rounding, and then 10 would be rounded
 to 8 again with even rounding.)




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_roundeven (rop, op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_sec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 127
 ret = mpfr_sec (rop, op, rnd)

 Set ROP to the secant of OP, cosecant of OP, cotangent of OP,
 rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_sec (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_sech


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 139
 ret = mpfr_sech (rop, op, rnd)

 Set ROP to the hyperbolic secant of OP, cosecant of OP, cotangent
 of OP, rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_sech (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_set


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2035
 ret = mpfr_set (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_set (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_set_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2037
 ret = mpfr_set_d (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_set_d (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
mpfr_set_decimal128


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2046
 ret = mpfr_set_decimal128 (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_set_decimal128 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
mpfr_set_decimal64


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2045
 ret = mpfr_set_decimal64 (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
 ret = mpfr_set_decimal64 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
mpfr_set_default_prec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 628
 mpfr_set_default_prec (prec)

 Set the default precision to be *exactly* PREC bits, where PREC can
 be any integer between ‘MPFR_PREC_MIN’ and ‘MPFR_PREC_MAX’.  The
 precision of a variable means the number of bits used to store its
 significand.  All subsequent calls to ‘mpfr_init’ or ‘mpfr_inits’
 will use this precision, but previously initialized variables are
 unaffected.  The default precision is set to 53 bits initially.

 Note: when MPFR is built with the ‘--enable-thread-safe’ configure
 option, the default precision is local to each thread.  *Note
 Memory Handling::, for more information.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 mpfr_set_default_prec (prec)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
mpfr_set_default_rounding_mode


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 132
 mpfr_set_default_rounding_mode (rnd)

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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 mpfr_set_default_rounding_mode (rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
mpfr_set_divby0


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 114
 mpfr_set_divby0 ()

 Set (raise) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
 mpfr_set_divby0 ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_set_emax


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1188
 ret = mpfr_set_emax (exp)

 Set the smallest and largest exponents allowed for a floating-point
 variable.  Return a non-zero value when EXP is not in the range
 accepted by the implementation (in that case the smallest or
 largest exponent is not changed), and zero otherwise.

 For the subsequent operations, it is the user’s responsibility to
 check that any floating-point value used as an input is in the new
 exponent range (for example using ‘mpfr_check_range’).  If a
 floating-point value outside the new exponent range is used as an
 input, the default behavior is undefined, in the sense of the ISO C
 standard; the behavior may also be explicitly documented, such as
 for ‘mpfr_check_range’.

 Note: Caches may still have values outside the current exponent
 range.  This is not an issue as the user cannot use these caches
 directly via the API (MPFR extends the exponent range internally
 when need be).

 If ‘emin’ > ‘emax’ and a floating-point value needs to be produced
 as output, the behavior is undefined (‘mpfr_set_emin’ and
 ‘mpfr_set_emax’ do not check this condition as it might occur
 between successive calls to these two functions).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
 ret = mpfr_set_emax (exp)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_set_emin


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1188
 ret = mpfr_set_emin (exp)

 Set the smallest and largest exponents allowed for a floating-point
 variable.  Return a non-zero value when EXP is not in the range
 accepted by the implementation (in that case the smallest or
 largest exponent is not changed), and zero otherwise.

 For the subsequent operations, it is the user’s responsibility to
 check that any floating-point value used as an input is in the new
 exponent range (for example using ‘mpfr_check_range’).  If a
 floating-point value outside the new exponent range is used as an
 input, the default behavior is undefined, in the sense of the ISO C
 standard; the behavior may also be explicitly documented, such as
 for ‘mpfr_check_range’.

 Note: Caches may still have values outside the current exponent
 range.  This is not an issue as the user cannot use these caches
 directly via the API (MPFR extends the exponent range internally
 when need be).

 If ‘emin’ > ‘emax’ and a floating-point value needs to be produced
 as output, the behavior is undefined (‘mpfr_set_emin’ and
 ‘mpfr_set_emax’ do not check this condition as it might occur
 between successive calls to these two functions).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
 ret = mpfr_set_emin (exp)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
mpfr_set_erangeflag


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 118
 mpfr_set_erangeflag ()

 Set (raise) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 mpfr_set_erangeflag ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_set_exp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 203
 ret = mpfr_set_exp (x, e)

 Set the exponent of X to E if X is a non-zero ordinary number and E
 is in the current exponent range, and return 0; otherwise, return a
 non-zero value (X is not changed).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
 ret = mpfr_set_exp (x, e)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_set_float128


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2044
 ret = mpfr_set_float128 (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_set_float128 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_set_flt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2039
 ret = mpfr_set_flt (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_set_flt (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_set_inexflag


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 116
 mpfr_set_inexflag ()

 Set (raise) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
 mpfr_set_inexflag ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_set_inf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 280
 mpfr_set_inf (x, sign)

 Set the variable X to NaN (Not-a-Number), infinity or zero
 respectively.  In ‘mpfr_set_inf’ or ‘mpfr_set_zero’, X is set to
 plus infinity or plus zero iff SIGN is nonnegative; in
 ‘mpfr_set_nan’, the sign bit of the result is unspecified.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 mpfr_set_inf (x, sign)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_set_ld


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2038
 ret = mpfr_set_ld (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_set_ld (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_set_nan


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 274
 mpfr_set_nan (x)

 Set the variable X to NaN (Not-a-Number), infinity or zero
 respectively.  In ‘mpfr_set_inf’ or ‘mpfr_set_zero’, X is set to
 plus infinity or plus zero iff SIGN is nonnegative; in
 ‘mpfr_set_nan’, the sign bit of the result is unspecified.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
 mpfr_set_nan (x)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_set_nanflag


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 115
 mpfr_set_nanflag ()

 Set (raise) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
 mpfr_set_nanflag ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_set_overflow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 116
 mpfr_set_overflow ()

 Set (raise) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
 mpfr_set_overflow ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_set_prec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 708
 mpfr_set_prec (x, prec)

 Set the precision of X to be *exactly* PREC bits, and set its value
 to NaN.  The previous value stored in X is lost.  It is equivalent
 to a call to ‘mpfr_clear(x)’ followed by a call to ‘mpfr_init2(x,
 prec)’, but more efficient as no allocation is done in case the
 current allocated space for the significand of X is enough.  The
 precision PREC can be any integer between ‘MPFR_PREC_MIN’ and
 ‘MPFR_PREC_MAX’.  In case you want to keep the previous value
 stored in X, use ‘mpfr_prec_round’ instead.

 Warning!  You must not use this function if X was initialized with
 ‘MPFR_DECL_INIT’ or with ‘mpfr_custom_init_set’ (*note Custom
 Interface::).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
 mpfr_set_prec (x, prec)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_set_si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2038
 ret = mpfr_set_si (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_set_si (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_set_si_2exp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 193
 ret = mpfr_set_si_2exp (rop, op, e, rnd)

 Set the value of ROP from OP multiplied by two to the power E,
 rounded toward the given direction RND.  Note that the input 0 is
 converted to +0.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_set_si_2exp (rop, op, e, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_set_sj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2038
 ret = mpfr_set_sj (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_set_sj (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_set_sj_2exp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 193
 ret = mpfr_set_sj_2exp (rop, op, e, rnd)

 Set the value of ROP from OP multiplied by two to the power E,
 rounded toward the given direction RND.  Note that the input 0 is
 converted to +0.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_set_sj_2exp (rop, op, e, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_set_str


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 810
 ret = mpfr_set_str (rop, s, base, rnd)

 Set ROP to the value of the string S in base BASE, rounded in the
 direction RND.  See the documentation of ‘mpfr_strtofr’ for a
 detailed description of the valid string formats.  Contrary to
 ‘mpfr_strtofr’, ‘mpfr_set_str’ requires the _whole_ string to
 represent a valid floating-point number.

 The meaning of the return value differs from other MPFR functions:
 it is 0 if the entire string up to the final null character is a
 valid number in base BASE; otherwise it is −1, and ROP may have
 changed (users interested in the *note ternary value:: should use
 ‘mpfr_strtofr’ instead).

 Note: it is preferable to use ‘mpfr_strtofr’ if one wants to
 distinguish between an infinite ROP value coming from an infinite S
 or from an overflow.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_set_str (rop, s, base, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_set_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2038
 ret = mpfr_set_ui (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_set_ui (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_set_ui_2exp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 193
 ret = mpfr_set_ui_2exp (rop, op, e, rnd)

 Set the value of ROP from OP multiplied by two to the power E,
 rounded toward the given direction RND.  Note that the input 0 is
 converted to +0.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_set_ui_2exp (rop, op, e, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_set_uj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2038
 ret = mpfr_set_uj (rop, op, rnd)

 Set the value of ROP from OP, rounded toward the given direction
 RND.  Note that the input 0 is converted to +0 by ‘mpfr_set_ui’,
 ‘mpfr_set_si’, ‘mpfr_set_uj’, ‘mpfr_set_sj’, The
 ‘mpfr_set_float128’ function is built only with the configure
 option ‘--enable-float128’, which requires the compiler or system
 provides the ‘_Float128’ data type (GCC 4.3 or later supports this
 data type); to use ‘mpfr_set_float128’, one should define the macro
 ‘MPFR_WANT_FLOAT128’ before including ‘mpfr.h’.  ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  If
 the system does not support the IEEE 754 standard, ‘mpfr_set_flt’,
 ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’ might not preserve the signed zeros.  The
 ‘mpfr_set_decimal64’ and ‘mpfr_set_decimal128’ functions are built
 only with the configure option ‘--enable-decimal-float’, and when
 the compiler or system provides the ‘_Decimal64’ and ‘_Decimal128’
 data type; to use those functions, one should define the macro
 ‘MPFR_WANT_DECIMAL_FLOATS’ before including ‘mpfr.h’.  ‘mpfr_set_q’
 might fail if the numerator (or the denominator) cannot be
 represented as a ‘mpfr_t’.

 For ‘mpfr_set’, the sign of a NaN is propagated in order to mimic
 the IEEE 754 ‘copy’ operation.  But contrary to IEEE 754, the NaN
 flag is set as usual.

 Note: If you want to store a floating-point constant to a ‘mpfr_t’,
 you should use ‘mpfr_set_str’ (or one of the MPFR constant
 functions, such as ‘mpfr_const_pi’ for Pi) instead of
 ‘mpfr_set_flt’, ‘mpfr_set_d’, ‘mpfr_set_ld’, ‘mpfr_set_decimal64’
 or ‘mpfr_set_decimal128’.  Otherwise the floating-point constant
 will be first converted into a reduced-precision (e.g., 53-bit)
 binary (or decimal, for ‘mpfr_set_decimal64’ and
 ‘mpfr_set_decimal128’) number before MPFR can work with it.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
 ret = mpfr_set_uj (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_set_uj_2exp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 193
 ret = mpfr_set_uj_2exp (rop, op, e, rnd)

 Set the value of ROP from OP multiplied by two to the power E,
 rounded toward the given direction RND.  Note that the input 0 is
 converted to +0.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_set_uj_2exp (rop, op, e, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
mpfr_set_underflow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 117
 mpfr_set_underflow ()

 Set (raise) the underflow, overflow, divide-by-zero, invalid,
 inexact and _erange_ flags.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
 mpfr_set_underflow ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
mpfr_set_zero


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 281
 mpfr_set_zero (x, sign)

 Set the variable X to NaN (Not-a-Number), infinity or zero
 respectively.  In ‘mpfr_set_inf’ or ‘mpfr_set_zero’, X is set to
 plus infinity or plus zero iff SIGN is nonnegative; in
 ‘mpfr_set_nan’, the sign bit of the result is unspecified.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
 mpfr_set_zero (x, sign)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_setsign


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 203
 ret = mpfr_setsign (rop, op, s, 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.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 ret = mpfr_setsign (rop, op, s, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_sgn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 243
 ret = mpfr_sgn (op)

 Return a positive value if OP > 0, zero if OP = 0, and a negative
 value if OP < 0.  If the operand is NaN, set the _erange_ flag and
 return zero.  This is equivalent to ‘mpfr_cmp_ui (op, 0)’, but more
 efficient.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
 ret = mpfr_sgn (op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_si_div


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 505
 ret = mpfr_si_div (rop, op1, op2, rnd)

 Set ROP to OP1/OP2 rounded in the direction RND.  When a result is
 zero, its sign is the product of the signs of the operands.  For
 types having no signed zeros, 0 is considered positive; but note
 that if OP1 is non-zero and OP2 is zero, the result might change
 from ±Inf to NaN in future MPFR versions if there is an opposite
 decision on the IEEE 754 side.  The same restrictions than for
 ‘mpfr_add_d’ apply to ‘mpfr_d_div’ and ‘mpfr_div_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_si_div (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_si_sub


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 417
 ret = mpfr_si_sub (rop, op1, op2, rnd)

 Set ROP to OP1 - OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) − 0 =
 (+0), (−0) − 0 = (−0), 0 − (+0) = (−0) and 0 − (−0) = (+0)).  The
 same restrictions than for ‘mpfr_add_d’ apply to ‘mpfr_d_sub’ and
 ‘mpfr_sub_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_si_sub (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_signbit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 166
 ret = mpfr_signbit (op)

 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).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
 ret = mpfr_signbit (op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_sin


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 121
 ret = mpfr_sin (rop, op, rnd)

 Set ROP to the cosine of OP, sine of OP, tangent of OP, rounded in
 the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_sin (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_sin_cos


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 456
 ret = mpfr_sin_cos (sop, cop, op, 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.  Return 0 iff
 both results are exact, more precisely it returns s+4c where s=0 if
 SOP is exact, s=1 if SOP is larger than the sine of OP, s=2 if SOP
 is smaller than the sine of OP, and similarly for c and the cosine
 of OP.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_sin_cos (sop, cop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_sinh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 123
 ret = mpfr_sinh (rop, op, rnd)

 Set ROP to the hyperbolic cosine, sine or tangent of OP, rounded in
 the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_sinh (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_sinh_cosh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 369
 ret = mpfr_sinh_cosh (sop, cop, op, 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.  Return 0 iff both results are exact (see ‘mpfr_sin_cos’
 for a more detailed description of the return value).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
 ret = mpfr_sinh_cosh (sop, cop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_sqr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 92
 ret = mpfr_sqr (rop, op, rnd)

 Set ROP to the square of OP rounded in the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_sqr (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_sqrt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 211
 ret = mpfr_sqrt (rop, op, rnd)

 Set ROP to the square root of OP rounded in the direction RND.  Set
 ROP to −0 if OP is −0, to be consistent with the IEEE 754 standard.
 Set ROP to NaN if OP is negative.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_sqrt (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_sqrt_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 214
 ret = mpfr_sqrt_ui (rop, op, rnd)

 Set ROP to the square root of OP rounded in the direction RND.  Set
 ROP to −0 if OP is −0, to be consistent with the IEEE 754 standard.
 Set ROP to NaN if OP is negative.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_sqrt_ui (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_strtofr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3653
 [ret, endptr] = mpfr_strtofr (rop, nptr, base, rnd)

 Read a floating-point number from a string NPTR in base BASE,
 rounded in the direction RND; BASE must be either 0 (to detect the
 base, as described below) or a number from 2 to 62 (otherwise the
 behavior is undefined).  If NPTR starts with valid data, the result
 is stored in ROP and ‘*ENDPTR’ points to the character just after
 the valid data (if ENDPTR is not a null pointer); otherwise ROP is
 set to zero (for consistency with ‘strtod’) and the value of NPTR
 is stored in the location referenced by ENDPTR (if ENDPTR is not a
 null pointer).  The usual ternary value is returned.

 Parsing follows the standard C ‘strtod’ function with some
 extensions.  After optional leading whitespace, one has a subject
 sequence consisting of an optional sign (‘+’ or ‘-’), and either
 numeric data or special data.  The subject sequence is defined as
 the longest initial subsequence of the input string, starting with
 the first non-whitespace character, that is of the expected form.

 The form of numeric data is a non-empty sequence of significand
 digits with an optional decimal-point character, and an optional
 exponent consisting of an exponent prefix followed by an optional
 sign and a non-empty sequence of decimal digits.  A significand
 digit is either a decimal digit or a Latin letter (62 possible
 characters), with ‘A’ = 10, ‘B’ = 11, ..., ‘Z’ = 35; case is
 ignored in bases less than or equal to 36, in bases larger than 36,
 ‘a’ = 36, ‘b’ = 37, ..., ‘z’ = 61.  The value of a significand
 digit must be strictly less than the base.  The decimal-point
 character can be either the one defined by the current locale or
 the period (the first one is accepted for consistency with the C
 standard and the practice, the second one is accepted to allow the
 programmer to provide MPFR numbers from strings in a way that does
 not depend on the current locale).  The exponent prefix can be ‘e’
 or ‘E’ for bases up to 10, or ‘@’ in any base; it indicates a
 multiplication by a power of the base.  In bases 2 and 16, the
 exponent prefix can also be ‘p’ or ‘P’, in which case the exponent,
 called _binary exponent_, indicates a multiplication by a power of
 2 instead of the base (there is a difference only for base 16); in
 base 16 for example ‘1p2’ represents 4 whereas ‘1@2’ represents
 256.  The value of an exponent is always written in base 10.

 If the argument BASE is 0, then the base is automatically detected
 as follows.  If the significand starts with ‘0b’ or ‘0B’, base 2 is
 assumed.  If the significand starts with ‘0x’ or ‘0X’, base 16 is
 assumed.  Otherwise base 10 is assumed.

 Note: The exponent (if present) must contain at least a digit.
 Otherwise the possible exponent prefix and sign are not part of the
 number (which ends with the significand).  Similarly, if ‘0b’,
 ‘0B’, ‘0x’ or ‘0X’ is not followed by a binary/hexadecimal digit,
 then the subject sequence stops at the character ‘0’, thus 0 is
 read.

 Special data (for infinities and NaN) can be ‘@inf@’ or
 ‘@nan@(n-char-sequence-opt)’, and if BASE <= 16, it can also be
 ‘infinity’, ‘inf’, ‘nan’ or ‘nan(n-char-sequence-opt)’, all case
 insensitive.  A ‘n-char-sequence-opt’ is a possibly empty string
 containing only digits, Latin letters and the underscore (0, 1, 2,
 ..., 9, a, b, ..., z, A, B, ..., Z, _).  Note: one has an optional
 sign for all data, even NaN.  For example, ‘-@nAn@(This_Is_Not_17)’
 is a valid representation for NaN in base 17.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
 [ret, endptr] = mpfr_strtofr (rop, nptr, base, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_sub


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 414
 ret = mpfr_sub (rop, op1, op2, rnd)

 Set ROP to OP1 - OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) − 0 =
 (+0), (−0) − 0 = (−0), 0 − (+0) = (−0) and 0 − (−0) = (+0)).  The
 same restrictions than for ‘mpfr_add_d’ apply to ‘mpfr_d_sub’ and
 ‘mpfr_sub_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_sub (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_sub_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 416
 ret = mpfr_sub_d (rop, op1, op2, rnd)

 Set ROP to OP1 - OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) − 0 =
 (+0), (−0) − 0 = (−0), 0 − (+0) = (−0) and 0 − (−0) = (+0)).  The
 same restrictions than for ‘mpfr_add_d’ apply to ‘mpfr_d_sub’ and
 ‘mpfr_sub_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 ret = mpfr_sub_d (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_sub_si


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 417
 ret = mpfr_sub_si (rop, op1, op2, rnd)

 Set ROP to OP1 - OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) − 0 =
 (+0), (−0) − 0 = (−0), 0 − (+0) = (−0) and 0 − (−0) = (+0)).  The
 same restrictions than for ‘mpfr_add_d’ apply to ‘mpfr_d_sub’ and
 ‘mpfr_sub_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_sub_si (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_sub_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 417
 ret = mpfr_sub_ui (rop, op1, op2, rnd)

 Set ROP to OP1 - OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) − 0 =
 (+0), (−0) − 0 = (−0), 0 − (+0) = (−0) and 0 − (−0) = (+0)).  The
 same restrictions than for ‘mpfr_add_d’ apply to ‘mpfr_d_sub’ and
 ‘mpfr_sub_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_sub_ui (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_subnormalize


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1701
 ret = mpfr_subnormalize (x, t, rnd)

 This function rounds X emulating subnormal number arithmetic: if X
 is outside the subnormal exponent range of the emulated
 floating-point system, this function just propagates the *note
 ternary value:: T; otherwise, it rounds X to precision
 ‘EXP(X)-emin+1’ according to rounding mode RND and previous ternary
 value T, avoiding double rounding problems.  More precisely in the
 subnormal domain, denoting by E the value of ‘emin’, X is rounded
 in fixed-point arithmetic to an integer multiple of two to the
 power E−1; as a consequence, 1.5 multiplied by two to the power E−1
 when T is zero is rounded to two to the power E with rounding to
 nearest.

 ‘PREC(X)’ is not modified by this function.  RND and T must be the
 rounding mode and the returned ternary value used when computing X
 (as in ‘mpfr_check_range’).  The subnormal exponent range is from
 ‘emin’ to ‘emin+PREC(X)-1’.  If the result cannot be represented in
 the current exponent range of MPFR (due to a too small ‘emax’), the
 behavior is undefined.  Note that unlike most functions, the result
 is compared to the exact one, not the input value X, i.e., the
 ternary value is propagated.

 As usual, if the returned ternary value is non zero, the inexact
 flag is set.  Moreover, if a second rounding occurred (because the
 input X was in the subnormal range), the underflow flag is set.

 Warning!  If you change ‘emin’ (with ‘mpfr_set_emin’) just before
 calling ‘mpfr_subnormalize’, you need to make sure that the value
 is in the current exponent range of MPFR.  But it is better to
 change ‘emin’ before any computation, if possible.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
 ret = mpfr_subnormalize (x, t, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_sum


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 694
 ret = mpfr_sum (rop, tab, n, rnd)

 Set ROP to the sum of all elements of TAB, whose size is N,
 correctly rounded in the direction RND.  Warning: for efficiency
 reasons, TAB is an array of pointers to ‘mpfr_t’, not an array of
 ‘mpfr_t’.  If N = 0, then the result is +0, and if N = 1, then the
 function is equivalent to ‘mpfr_set’.  For the special exact cases,
 the result is the same as the one obtained with a succession of
 additions (‘mpfr_add’) in infinite precision.  In particular, if
 the result is an exact zero and N >= 1:
 • if all the inputs have the same sign (i.e., all +0 or all −0),
 • otherwise, either because all inputs are zeros with at least a




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_sum (rop, tab, n, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_swap


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 627
 mpfr_swap (x, y)

 Swap the structures pointed to by X and Y.  In particular, the
 values are exchanged without rounding (this may be different from
 three ‘mpfr_set’ calls using a third auxiliary variable).

 Warning!  Since the precisions are exchanged, this will affect
 future assignments.  Moreover, since the significand pointers are
 also exchanged, you must not use this function if the allocation
 method used for X and/or Y does not permit it.  This is the case
 when X and/or Y were declared and initialized with
 ‘MPFR_DECL_INIT’, and possibly with ‘mpfr_custom_init_set’ (*note
 Custom Interface::).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
 mpfr_swap (x, y)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
mpfr_tan


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 121
 ret = mpfr_tan (rop, op, rnd)

 Set ROP to the cosine of OP, sine of OP, tangent of OP, rounded in
 the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
 ret = mpfr_tan (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_tanh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 123
 ret = mpfr_tanh (rop, op, rnd)

 Set ROP to the hyperbolic cosine, sine or tangent of OP, rounded in
 the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_tanh (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
mpfr_total_order_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 673
 ret = mpfr_total_order_p (x, y)

 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.  Contrary to ‘mpfr_cmp (x,
 y)’, which returns a ternary value, ‘mpfr_total_order_p’ returns a
 binary value (zero or non-zero).  In particular,
 ‘mpfr_total_order_p (x, x)’ returns true, ‘mpfr_total_order_p (-0,
 +0)’ returns true and ‘mpfr_total_order_p (+0, -0)’ returns false.
 The sign bit of NaN also matters.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_total_order_p (x, y)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
mpfr_trunc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1855
 ret = mpfr_trunc (rop, op)

 Set ROP to OP rounded to an integer.  ‘mpfr_rint’ rounds to the
 nearest representable integer in the given direction RND, and the
 other five functions behave in a similar way with some fixed
 rounding mode:
 • ‘mpfr_ceil’: to the next higher or equal representable integer
 • ‘mpfr_floor’ to the next lower or equal representable integer
 • ‘mpfr_round’ to the nearest representable integer, rounding
 • ‘mpfr_roundeven’ to the nearest representable integer,
 • ‘mpfr_trunc’ to the next representable integer toward zero
 When OP is a zero or an infinity, set ROP to the same value (with
 the same sign).

 The return value is zero when the result is exact, positive when it
 is greater than the original value of OP, and negative when it is
 smaller.  More precisely, the return value is 0 when OP is an
 integer representable in ROP, 1 or −1 when OP is an integer that is
 not representable in ROP, 2 or −2 when OP is not an integer.

 When OP is NaN, the NaN flag is set as usual.  In the other cases,
 the inexact flag is set when ROP differs from OP, following the ISO
 C99 rule for the ‘rint’ function.  If you want the behavior to be
 more like IEEE 754 / ISO TS 18661-1, i.e., the usual behavior where
 the round-to-integer function is regarded as any other mathematical
 function, you should use one the ‘mpfr_rint_*’ functions instead.

 Note that no double rounding is performed; for instance, 10.5
 (1010.1 in binary) is rounded by ‘mpfr_rint’ with rounding to
 nearest to 12 (1100 in binary) in 2-bit precision, because the two
 enclosing numbers representable on two bits are 8 and 12, and the
 closest is 12.  (If one first rounded to an integer, one would
 round 10.5 to 10 with even rounding, and then 10 would be rounded
 to 8 again with even rounding.)




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 ret = mpfr_trunc (rop, op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_ui_div


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 505
 ret = mpfr_ui_div (rop, op1, op2, rnd)

 Set ROP to OP1/OP2 rounded in the direction RND.  When a result is
 zero, its sign is the product of the signs of the operands.  For
 types having no signed zeros, 0 is considered positive; but note
 that if OP1 is non-zero and OP2 is zero, the result might change
 from ±Inf to NaN in future MPFR versions if there is an opposite
 decision on the IEEE 754 side.  The same restrictions than for
 ‘mpfr_add_d’ apply to ‘mpfr_d_div’ and ‘mpfr_div_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_ui_div (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_ui_pow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1369
 ret = mpfr_ui_pow (rop, op1, op2, rnd)

 Set ROP to OP1 raised to OP2, rounded in the direction RND.
 Special values are handled as described in the ISO C99 and
 IEEE 754-2008 standards for the ‘pow’ function:
 • ‘pow(±0, Y)’ returns plus or minus infinity for Y a negative
 • ‘pow(±0, Y)’ returns plus infinity for Y negative and not an
 • ‘pow(±0, Y)’ returns plus or minus zero for Y a positive odd
 • ‘pow(±0, Y)’ returns plus zero for Y positive and not an odd
 • ‘pow(-1, ±Inf)’ returns 1.
 • ‘pow(+1, Y)’ returns 1 for any Y, even a NaN.
 • ‘pow(X, ±0)’ returns 1 for any X, even a NaN.
 • ‘pow(X, Y)’ returns NaN for finite negative X and finite
 • ‘pow(X, -Inf)’ returns plus infinity for 0 < abs(x) < 1, and
 • ‘pow(X, +Inf)’ returns plus zero for 0 < abs(x) < 1, and plus
 • ‘pow(-Inf, Y)’ returns minus zero for Y a negative odd
 • ‘pow(-Inf, Y)’ returns plus zero for Y negative and not an odd
 • ‘pow(-Inf, Y)’ returns minus infinity for Y a positive odd
 • ‘pow(-Inf, Y)’ returns plus infinity for Y positive and not an
 • ‘pow(+Inf, Y)’ returns plus zero for Y negative, and plus
 Note: When 0 is of integer type, it is regarded as +0 by these
 functions.  We do not use the usual limit rules in this case, as
 these rules are not used for ‘pow’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_ui_pow (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
mpfr_ui_pow_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1372
 ret = mpfr_ui_pow_ui (rop, op1, op2, rnd)

 Set ROP to OP1 raised to OP2, rounded in the direction RND.
 Special values are handled as described in the ISO C99 and
 IEEE 754-2008 standards for the ‘pow’ function:
 • ‘pow(±0, Y)’ returns plus or minus infinity for Y a negative
 • ‘pow(±0, Y)’ returns plus infinity for Y negative and not an
 • ‘pow(±0, Y)’ returns plus or minus zero for Y a positive odd
 • ‘pow(±0, Y)’ returns plus zero for Y positive and not an odd
 • ‘pow(-1, ±Inf)’ returns 1.
 • ‘pow(+1, Y)’ returns 1 for any Y, even a NaN.
 • ‘pow(X, ±0)’ returns 1 for any X, even a NaN.
 • ‘pow(X, Y)’ returns NaN for finite negative X and finite
 • ‘pow(X, -Inf)’ returns plus infinity for 0 < abs(x) < 1, and
 • ‘pow(X, +Inf)’ returns plus zero for 0 < abs(x) < 1, and plus
 • ‘pow(-Inf, Y)’ returns minus zero for Y a negative odd
 • ‘pow(-Inf, Y)’ returns plus zero for Y negative and not an odd
 • ‘pow(-Inf, Y)’ returns minus infinity for Y a positive odd
 • ‘pow(-Inf, Y)’ returns plus infinity for Y positive and not an
 • ‘pow(+Inf, Y)’ returns plus zero for Y negative, and plus
 Note: When 0 is of integer type, it is regarded as +0 by these
 functions.  We do not use the usual limit rules in this case, as
 these rules are not used for ‘pow’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
 ret = mpfr_ui_pow_ui (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_ui_sub


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 417
 ret = mpfr_ui_sub (rop, op1, op2, rnd)

 Set ROP to OP1 - OP2 rounded in the direction RND.  The IEEE 754
 rules are used, in particular for signed zeros.  But for types
 having no signed zeros, 0 is considered unsigned (i.e., (+0) − 0 =
 (+0), (−0) − 0 = (−0), 0 − (+0) = (−0) and 0 − (−0) = (+0)).  The
 same restrictions than for ‘mpfr_add_d’ apply to ‘mpfr_d_sub’ and
 ‘mpfr_sub_d’.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
 ret = mpfr_ui_sub (rop, op1, op2, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_underflow_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 168
 ret = mpfr_underflow_p ()

 Return the corresponding (underflow, overflow, divide-by-zero,
 invalid, inexact, _erange_) flag, which is non-zero iff the flag is
 set.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
 ret = mpfr_underflow_p ()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mpfr_unordered_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 127
 ret = mpfr_unordered_p (op1, op2)

 Return non-zero if OP1 or OP2 is a NaN (i.e., they cannot be
 compared), zero otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_unordered_p (op1, op2)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
mpfr_y0


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 334
 ret = mpfr_y0 (rop, op, rnd)

 Set ROP to the value of the second kind Bessel function of order 0
 (resp. 1 and N) on OP, rounded in the direction RND.  When OP is
 NaN or negative, ROP is always set to NaN.  When OP is +Inf, ROP is
 set to +0.  When OP is zero, ROP is set to +Inf or −Inf depending
 on the parity and sign of N.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_y0 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
mpfr_y1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 334
 ret = mpfr_y1 (rop, op, rnd)

 Set ROP to the value of the second kind Bessel function of order 0
 (resp. 1 and N) on OP, rounded in the direction RND.  When OP is
 NaN or negative, ROP is always set to NaN.  When OP is +Inf, ROP is
 set to +0.  When OP is zero, ROP is set to +Inf or −Inf depending
 on the parity and sign of N.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 ret = mpfr_y1 (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
mpfr_yn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 337
 ret = mpfr_yn (rop, n, op, rnd)

 Set ROP to the value of the second kind Bessel function of order 0
 (resp. 1 and N) on OP, rounded in the direction RND.  When OP is
 NaN or negative, ROP is always set to NaN.  When OP is +Inf, ROP is
 set to +0.  When OP is zero, ROP is set to +Inf or −Inf depending
 on the parity and sign of N.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 ret = mpfr_yn (rop, n, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mpfr_zero_p


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 239
 ret = mpfr_zero_p (op)

 Return non-zero if OP is respectively NaN, an infinity, an ordinary
 number (i.e., neither NaN nor an infinity), zero, or a regular
 number (i.e., neither NaN, nor an infinity nor zero).  Return zero
 otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 ret = mpfr_zero_p (op)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mpfr_zeta


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 123
 ret = mpfr_zeta (rop, op, rnd)

 Set ROP to the value of the Riemann Zeta function on OP, rounded in
 the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
 ret = mpfr_zeta (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
mpfr_zeta_ui


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 126
 ret = mpfr_zeta_ui (rop, op, rnd)

 Set ROP to the value of the Riemann Zeta function on OP, rounded in
 the direction RND.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
 ret = mpfr_zeta_ui (rop, op, rnd)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
test_apa


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
 Self-test for @mpfr_t class and MPFR-low-level interface.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
 Self-test for @mpfr_t class and MPFR-low-level interface.






