Next: Basic Arithmetic Functions, Previous: Combined Initialization and Assignment Functions, Up: MPFR Interface [Index]
Convert op to a float (respectively double,
long double or _Decimal64), using the rounding mode rnd.
If op is NaN, some fixed NaN (either quiet or signaling) or the result
of 0.0/0.0 is returned. If op is ±Inf, an infinity of the same
sign or the result of ±1.0/0.0 is returned. If op is zero, these
functions return a zero, trying to preserve its sign, if possible.
The mpfr_get_decimal64 function is built only under some conditions:
see the documentation of mpfr_set_decimal64.
Convert op to a long, an unsigned long,
an intmax_t or an uintmax_t (respectively) after rounding
it 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.
See also mpfr_fits_slong_p, mpfr_fits_ulong_p,
mpfr_fits_intmax_p and mpfr_fits_uintmax_p.
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.
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.
Put the scaled significand of op (regarded as an integer, with the
precision of op) into rop, and return the exponent exp
(which may be outside the current exponent range) such that op
exactly equals
rop times 2 raised to the power exp.
If op is zero, the minimal exponent emin is returned.
If op is NaN or an infinity, the erange flag is set, rop
is set to 0, and the the minimal exponent emin is returned.
The returned exponent may be less than the minimal exponent emin
of MPFR numbers in the current exponent range; in case the exponent is
not representable in the mpfr_exp_t type, the erange flag
is set and the minimal value of the mpfr_exp_t type is returned.
Convert op to a mpz_t, after rounding it with respect to
rnd. If op is NaN or an infinity, the erange flag is
set, rop is set to 0, and 0 is returned.
Convert op to a mpf_t, after rounding it with respect to
rnd.
The erange flag is set if op is NaN or an infinity, which
do not exist in MPF. If op is NaN, then rop is undefined.
If op is +Inf (resp. −Inf), then rop is set to
the maximum (resp. minimum) value in the precision of the MPF number;
if a future MPF version supports infinities, this behavior will be
considered incorrect and will change (portable programs should assume
that rop is set either to this finite number or to an infinite
number).
Note that since MPFR currently has the same exponent type as MPF (but
not with the same radix), the range of values is much larger in MPF
than in MPFR, so that an overflow or underflow is not possible.
Convert op to a string of digits in base b, with rounding in
the direction rnd, where n is either zero (see below) or the
number of significant digits output in the string; in the latter case,
n must be greater or equal to 2. The base may vary from 2 to 62;
otherwise the function does nothing and immediately returns a null pointer.
If the input number is an ordinary 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 chosen large enough so that re-reading the printed value with the same precision, assuming both output and input use rounding to nearest, will recover the original value of op. More precisely, in most cases, the chosen precision of str is the minimal precision m depending only on p = PREC(op) and b that satisfies the above property, i.e., m = 1 + ceil(p*log(2)/log(b)), with p replaced by p−1 if b is a power of 2, but in some very rare cases, it might be m+1 (the smallest case for bases up to 62 is when p equals 186564318007 for bases 7 and 49).
If str is a null pointer, space for the significand is allocated using
the current allocation function 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, i.e., at least max(n + 2, 7).
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).
Note: The NaN and inexact flags are currently not set when need be; this will be fixed in future versions. Programmers should currently assume that whether the flags are set by this function is unspecified.
Free a string allocated by mpfr_get_str using the current unallocation
function.
The block is assumed to be strlen(str)+1 bytes.
For more information about how it is done:
see Section “Custom Allocation” in GNU MP.
Return non-zero if op would fit in the respective C data type,
respectively unsigned long, long, unsigned int,
int, unsigned short, short, uintmax_t,
intmax_t, when rounded to an integer in the direction rnd.
Next: Basic Arithmetic Functions, Previous: Combined Initialization and Assignment Functions, Up: MPFR Interface [Index]