# 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.2




# 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: 547
 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: 512
 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: 1885
 ret = mpfr_atan2 (rop, y, x, rnd)

 For ‘mpfr_atan2’, set ROP to the arc-tangent2 of Y and X, rounded
 in the direction RND: if X > 0, then ‘atan2(Y, X)’ returns
 atan(Y/X); if X < 0, then ‘atan2(Y, X)’ returns the sign of Y
 multiplied by 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.  The
 function ‘mpfr_atan2u’ behaves similarly, except the result is
 multiplied by U and divided by 2 Pi; and ‘mpfr_atan2pi’ is the same
 as ‘mpfr_atan2u’ with U = 2.  For example, if U equals 360,
 ‘mpfr_atan2u’ returns the arc-tangent in degrees, with values from
 −180 to 180.

 ‘atan2(Y, 0)’ does not raise any floating-point exception.  Special
 values are handled as described in the ISO C99 and IEEE 754
 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: 210
 ret = mpfr_buildopt_float128_p ()

 Return a non-zero value if MPFR was compiled with binary128 support
 (a.k.a. float128), return zero otherwise.  *Note Nomenclature and
 Types:: for additional information.




# 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: 1978
 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 EXP(B) − ERR
 where EXP(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: 503
 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 operation of the IEEE 754
 standard.




# 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: 1858
 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 of 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: 390
 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: 388
 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: 387
 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: 385
 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 as 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 as 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: 202
 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 as 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 as 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 as 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 as 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: 581
 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 the factorial of 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: 244
 ret = mpfr_expm1 (rop, op, rnd)

 Set ROP to the exponential of OP followed by a subtraction by one
 (resp. 2 power of OP followed by a subtraction by one, and 10 power
 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: 876
 ret = mpfr_fits_intmax_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long int’, ‘long int’, ‘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: 874
 ret = mpfr_fits_sint_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long int’, ‘long int’, ‘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: 875
 ret = mpfr_fits_slong_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long int’, ‘long int’, ‘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: 876
 ret = mpfr_fits_sshort_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long int’, ‘long int’, ‘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: 874
 ret = mpfr_fits_uint_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long int’, ‘long int’, ‘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: 877
 ret = mpfr_fits_uintmax_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long int’, ‘long int’, ‘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: 875
 ret = mpfr_fits_ulong_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long int’, ‘long int’, ‘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: 876
 ret = mpfr_fits_ushort_p (op, rnd)

 Return non-zero if OP would fit in the respective C data type,
 respectively ‘unsigned long int’, ‘long int’, ‘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: 1859
 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 of 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: 353
 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: 371
 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: 371
 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: 1238
 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’, ‘mpfr_fmod_ui’
 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 int’ minus one), with the sign of X
 divided by Y (except if those low bits are all zero, in which case
 zero is returned).  If the result is NaN, the value of *Q is
 unspecified.  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: 1246
 [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’, ‘mpfr_fmod_ui’
 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 int’ minus one), with the sign of X
 divided by Y (except if those low bits are all zero, in which case
 zero is returned).  If the result is NaN, the value of *Q is
 unspecified.  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: 353
 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: 479
 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.

 Note: It is allowed to modify the string allocated by
 ‘mpfr_get_str’; but when ‘mpfr_free_str’ is called, its length must
 be the same as the original one (unless it is guaranteed that the
 unallocation function ignores its size parameter).




# 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: 384
 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: 584
 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: 593
 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: 734
 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 NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned (the sign bit is not preserved).  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: 547
 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: 743
 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 NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned (the sign bit is not preserved).  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: 742
 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 NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned (the sign bit is not preserved).  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: 391
 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: 391
 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: 741
 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 NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned (the sign bit is not preserved).  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: 736
 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 NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned (the sign bit is not preserved).  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: 735
 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 NaN (either quiet or signaling) or the result of
 0.0/0.0 is returned (the sign bit is not preserved).  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: 703
 ret = mpfr_get_si (op, rnd)

 Convert OP to a ‘long int’, an ‘unsigned long int’, 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: 703
 ret = mpfr_get_sj (op, rnd)

 Convert OP to a ‘long int’, an ‘unsigned long int’, 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: 3086
 [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: 566
 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 times 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: 703
 ret = mpfr_get_ui (op, rnd)

 Convert OP to a ‘long int’, an ‘unsigned long int’, 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: 703
 ret = mpfr_get_uj (op, rnd)

 Convert OP to a ‘long int’, an ‘unsigned long int’, 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: 377
 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 (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: 383
 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 positive or negative
 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: 383
 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 positive or negative
 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: 386
 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 positive or negative
 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: 499
 [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 non-positive 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: 201
 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: 423
 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 non-positive
 integer, set ROP to +Inf, following the general rules on special
 values.  When −2k − 1 < OP < −2k, k being a non-negative 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: 346
 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 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: 348
 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 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: 221
 ret = mpfr_log1p (rop, op, rnd)

 Set ROP to the logarithm of one plus OP (in radix two for
 ‘mpfr_log2p1’, and in radix ten for ‘mpfr_log10p1’), 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: 347
 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 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: 349
 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 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: 583
 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).  As usual, the
 NaN flag is set only when the result is NaN, i.e., when both OP1
 and OP2 are NaN.

 Note: These functions correspond to the minimumNumber and
 maximumNumber operations of IEEE 754-2019 for the result.  But in
 MPFR, the NaN flag is set only when _both_ operands are NaN.




# 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: 583
 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).  As usual, the
 NaN flag is set only when the result is NaN, i.e., when both OP1
 and OP2 are NaN.

 Note: These functions correspond to the minimumNumber and
 maximumNumber operations of IEEE 754-2019 for the result.  But in
 MPFR, the NaN flag is set only when _both_ operands are NaN.




# 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: 416
 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 as for ‘mpfr_add_d’ apply to
 ‘mpfr_mul_d’.  Note: when OP1 and OP2 are equal, use ‘mpfr_sqr’
 instead of ‘mpfr_mul’ for better efficiency.




# 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: 418
 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 as for ‘mpfr_add_d’ apply to
 ‘mpfr_mul_d’.  Note: when OP1 and OP2 are equal, use ‘mpfr_sqr’
 instead of ‘mpfr_mul’ for better efficiency.




# 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: 419
 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 as for ‘mpfr_add_d’ apply to
 ‘mpfr_mul_d’.  Note: when OP1 and OP2 are equal, use ‘mpfr_sqr’
 instead of ‘mpfr_mul’ for better efficiency.




# 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: 419
 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 as for ‘mpfr_add_d’ apply to
 ‘mpfr_mul_d’.  Note: when OP1 and OP2 are equal, use ‘mpfr_sqr’
 instead of ‘mpfr_mul’ for better efficiency.




# 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: 547
 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: 91
 mpfr_nextabove (x)

 Equivalent to ‘mpfr_nexttoward’ where Y is +Inf (resp. −Inf).




# 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: 91
 mpfr_nextbelow (x)

 Equivalent to ‘mpfr_nexttoward’ where Y is +Inf (resp. −Inf).




# 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: 735
 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.

 Note: Concerning the exceptions and the sign of 0, the behavior
 differs from the ISO C ‘nextafter’ and ‘nexttoward’ functions.  It
 is similar to the nextUp and nextDown operations from IEEE 754
 (introduced in its 2008 revision).




# 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: 1661
 ret = mpfr_pow (rop, op1, op2, rnd)

 Set ROP to OP1 raised to OP2, rounded in the direction RND.  The
 ‘mpfr_powr’ function corresponds to the ‘powr’ function from
 IEEE 754, i.e., it computes the exponential of OP2 multiplied by
 the logarithm of OP1.  The ‘mpfr_pown’ function is just an alias
 for ‘mpfr_pow_sj’ (defined with ‘#define mpfr_pown mpfr_pow_sj’),
 to follow the C2x function ‘pown’.  Special values are handled as
 described in the ISO C99 and IEEE 754 standards for the ‘pow’
 function:
 • ‘pow(±0, Y)’ returns ±Inf for Y a negative odd integer.
 • ‘pow(±0, Y)’ returns +Inf for Y negative and not an odd
 • ‘pow(±0, Y)’ returns ±0 for Y a positive odd integer.
 • ‘pow(±0, Y)’ returns +0 for Y positive and not an odd integer.
 • ‘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 +Inf for 0 < abs(x) < 1, and +0 for
 • ‘pow(X, +Inf)’ returns +0 for 0 < abs(x) < 1, and +Inf for
 • ‘pow(-Inf, Y)’ returns −0 for Y a negative odd integer.
 • ‘pow(-Inf, Y)’ returns +0 for Y negative and not an odd
 • ‘pow(-Inf, Y)’ returns −Inf for Y a positive odd integer.
 • ‘pow(-Inf, Y)’ returns +Inf for Y positive and not an odd
 • ‘pow(+Inf, Y)’ returns +0 for Y negative, and +Inf for Y
 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: 1664
 ret = mpfr_pow_si (rop, op1, op2, rnd)

 Set ROP to OP1 raised to OP2, rounded in the direction RND.  The
 ‘mpfr_powr’ function corresponds to the ‘powr’ function from
 IEEE 754, i.e., it computes the exponential of OP2 multiplied by
 the logarithm of OP1.  The ‘mpfr_pown’ function is just an alias
 for ‘mpfr_pow_sj’ (defined with ‘#define mpfr_pown mpfr_pow_sj’),
 to follow the C2x function ‘pown’.  Special values are handled as
 described in the ISO C99 and IEEE 754 standards for the ‘pow’
 function:
 • ‘pow(±0, Y)’ returns ±Inf for Y a negative odd integer.
 • ‘pow(±0, Y)’ returns +Inf for Y negative and not an odd
 • ‘pow(±0, Y)’ returns ±0 for Y a positive odd integer.
 • ‘pow(±0, Y)’ returns +0 for Y positive and not an odd integer.
 • ‘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 +Inf for 0 < abs(x) < 1, and +0 for
 • ‘pow(X, +Inf)’ returns +0 for 0 < abs(x) < 1, and +Inf for
 • ‘pow(-Inf, Y)’ returns −0 for Y a negative odd integer.
 • ‘pow(-Inf, Y)’ returns +0 for Y negative and not an odd
 • ‘pow(-Inf, Y)’ returns −Inf for Y a positive odd integer.
 • ‘pow(-Inf, Y)’ returns +Inf for Y positive and not an odd
 • ‘pow(+Inf, Y)’ returns +0 for Y negative, and +Inf for Y
 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: 1664
 ret = mpfr_pow_ui (rop, op1, op2, rnd)

 Set ROP to OP1 raised to OP2, rounded in the direction RND.  The
 ‘mpfr_powr’ function corresponds to the ‘powr’ function from
 IEEE 754, i.e., it computes the exponential of OP2 multiplied by
 the logarithm of OP1.  The ‘mpfr_pown’ function is just an alias
 for ‘mpfr_pow_sj’ (defined with ‘#define mpfr_pown mpfr_pow_sj’),
 to follow the C2x function ‘pown’.  Special values are handled as
 described in the ISO C99 and IEEE 754 standards for the ‘pow’
 function:
 • ‘pow(±0, Y)’ returns ±Inf for Y a negative odd integer.
 • ‘pow(±0, Y)’ returns +Inf for Y negative and not an odd
 • ‘pow(±0, Y)’ returns ±0 for Y a positive odd integer.
 • ‘pow(±0, Y)’ returns +0 for Y positive and not an odd integer.
 • ‘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 +Inf for 0 < abs(x) < 1, and +0 for
 • ‘pow(X, +Inf)’ returns +0 for 0 < abs(x) < 1, and +Inf for
 • ‘pow(-Inf, Y)’ returns −0 for Y a negative odd integer.
 • ‘pow(-Inf, Y)’ returns +0 for Y negative and not an odd
 • ‘pow(-Inf, Y)’ returns −Inf for Y a positive odd integer.
 • ‘pow(-Inf, Y)’ returns +Inf for Y positive and not an odd
 • ‘pow(+Inf, Y)’ returns +0 for Y negative, and +Inf for Y
 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: 865
 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: 451
 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 standard (Section 9.2.1), which is −Inf instead of +Inf.
 However, ‘mpfr_rec_sqrt’ is equivalent to ‘mpfr_rootn_si’ with
 N = −2.




# 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: 1243
 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’, ‘mpfr_fmod_ui’
 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 int’ minus one), with the sign of X
 divided by Y (except if those low bits are all zero, in which case
 zero is returned).  If the result is NaN, the value of *Q is
 unspecified.  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: 1245
 [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’, ‘mpfr_fmod_ui’
 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 int’ minus one), with the sign of X
 divided by Y (except if those low bits are all zero, in which case
 zero is returned).  If the result is NaN, the value of *Q is
 unspecified.  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: 1863
 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 of 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: 462
 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 IEEE 754-2008, where rootn was introduced,
 and behaves differently from the IEEE 754 rootn operation.  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: 510
 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 operation of the IEEE 754
 standard.




# 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: 1859
 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 of 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: 1863
 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 of 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: 1832
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 1834
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 1843
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 1842
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 1174
 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: 1174
 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: 1841
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 1836
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 302
 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
 positive infinity (+Inf) or positive zero (+0) iff SIGN is
 non-negative; 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: 1835
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 296
 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
 positive infinity (+Inf) or positive zero (+0) iff SIGN is
 non-negative; 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: 1835
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 1835
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 847
 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 BASE (with its special value 0) and 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: 1835
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 1835
 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’, ‘mpfr_set_z’,
 ‘mpfr_set_q’ and ‘mpfr_set_f’, regardless of the rounding mode.  To
 use the ‘mpfr_set_float128’ function, see *note Nomenclature and
 Types::.  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 (and
 in any case they don't preserve the sign bit of NaN).  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: 303
 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
 positive infinity (+Inf) or positive zero (+0) iff SIGN is
 non-negative; 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 as 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 as 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: 464
 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: 293
 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
 (thus this differs from ‘mpfr_rootn_ui’ and ‘mpfr_rootn_si’ with
 N = 2).  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: 296
 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
 (thus this differs from ‘mpfr_rootn_ui’ and ‘mpfr_rootn_si’ with
 N = 2).  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: 3686
 [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 with the rules of the C locale.  An
 ‘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 as 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 as 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 as 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 as 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: 1717
 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, if EXP(X) denotes the exponent of X,
 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.

 The precision PREC(X) of 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)−2.  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: 669
 ret = mpfr_total_order_p (x, y)

 This function implements the totalOrder predicate from IEEE 754,
 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: 1859
 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 of 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 as 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: 1664
 ret = mpfr_ui_pow (rop, op1, op2, rnd)

 Set ROP to OP1 raised to OP2, rounded in the direction RND.  The
 ‘mpfr_powr’ function corresponds to the ‘powr’ function from
 IEEE 754, i.e., it computes the exponential of OP2 multiplied by
 the logarithm of OP1.  The ‘mpfr_pown’ function is just an alias
 for ‘mpfr_pow_sj’ (defined with ‘#define mpfr_pown mpfr_pow_sj’),
 to follow the C2x function ‘pown’.  Special values are handled as
 described in the ISO C99 and IEEE 754 standards for the ‘pow’
 function:
 • ‘pow(±0, Y)’ returns ±Inf for Y a negative odd integer.
 • ‘pow(±0, Y)’ returns +Inf for Y negative and not an odd
 • ‘pow(±0, Y)’ returns ±0 for Y a positive odd integer.
 • ‘pow(±0, Y)’ returns +0 for Y positive and not an odd integer.
 • ‘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 +Inf for 0 < abs(x) < 1, and +0 for
 • ‘pow(X, +Inf)’ returns +0 for 0 < abs(x) < 1, and +Inf for
 • ‘pow(-Inf, Y)’ returns −0 for Y a negative odd integer.
 • ‘pow(-Inf, Y)’ returns +0 for Y negative and not an odd
 • ‘pow(-Inf, Y)’ returns −Inf for Y a positive odd integer.
 • ‘pow(-Inf, Y)’ returns +Inf for Y positive and not an odd
 • ‘pow(+Inf, Y)’ returns +0 for Y negative, and +Inf for Y
 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: 1667
 ret = mpfr_ui_pow_ui (rop, op1, op2, rnd)

 Set ROP to OP1 raised to OP2, rounded in the direction RND.  The
 ‘mpfr_powr’ function corresponds to the ‘powr’ function from
 IEEE 754, i.e., it computes the exponential of OP2 multiplied by
 the logarithm of OP1.  The ‘mpfr_pown’ function is just an alias
 for ‘mpfr_pow_sj’ (defined with ‘#define mpfr_pown mpfr_pow_sj’),
 to follow the C2x function ‘pown’.  Special values are handled as
 described in the ISO C99 and IEEE 754 standards for the ‘pow’
 function:
 • ‘pow(±0, Y)’ returns ±Inf for Y a negative odd integer.
 • ‘pow(±0, Y)’ returns +Inf for Y negative and not an odd
 • ‘pow(±0, Y)’ returns ±0 for Y a positive odd integer.
 • ‘pow(±0, Y)’ returns +0 for Y positive and not an odd integer.
 • ‘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 +Inf for 0 < abs(x) < 1, and +0 for
 • ‘pow(X, +Inf)’ returns +0 for 0 < abs(x) < 1, and +Inf for
 • ‘pow(-Inf, Y)’ returns −0 for Y a negative odd integer.
 • ‘pow(-Inf, Y)’ returns +0 for Y negative and not an odd
 • ‘pow(-Inf, Y)’ returns −Inf for Y a positive odd integer.
 • ‘pow(-Inf, Y)’ returns +Inf for Y positive and not an odd
 • ‘pow(+Inf, Y)’ returns +0 for Y negative, and +Inf for Y
 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 as 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.






