public static char_ptr mpfr_get_str(
	char_ptr str,
	ref mpfr_exp_t expptr,
	int b,
	size_t n,
	mpfr_t op,
	mpfr_rnd_t rnd
)

Public Shared Function mpfr_get_str ( 
	str As char_ptr,
	ByRef expptr As mpfr_exp_t,
	b As Integer,
	n As size_t,
	op As mpfr_t,
	rnd As mpfr_rnd_t
) As char_ptr

public:
static char_ptr mpfr_get_str(
	char_ptr str, 
	mpfr_exp_t% expptr, 
	int b, 
	size_t n, 
	mpfr_t^ op, 
	mpfr_rnd_t rnd
)

static member mpfr_get_str : 
        str : char_ptr * 
        expptr : mpfr_exp_t byref * 
        b : int * 
        n : size_t * 
        op : mpfr_t * 
        rnd : mpfr_rnd_t -> char_ptr 

Parameters

str

Type: Math.Gmp.Nativechar_ptr
The result string.

expptr

Type: Math.Mpfr.Nativempfr_exp_t
The returned exponent.

b

Type: SystemInt32
The base.

n

Type: Math.Gmp.Nativesize_t
The number of digits in the result string.

op

Type: Math.Mpfr.Nativempfr_t
The operand floating-point number.

rnd

Type: Math.Mpfr.Nativempfr_rnd_t
The rounding direction.

Return Value

The base may vary from 2 to 62; otherwise the function does nothing and immediately returns a null pointer.

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 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 allocation function (see GNU MPFR - 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 m + 1, as discussed 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.

Reference