- Function:
`double`

**mpf_get_d**`(const mpf_t`

¶`op`) Convert

`op`to a`double`

, truncating if necessary (i.e. rounding towards zero).If the exponent in

`op`is too big or too small to fit a`double`

then the result is system dependent. For too big an infinity is returned when available. For too small*0.0*is normally returned. Hardware overflow, underflow and denorm traps may or may not occur.

- Function:
`double`

**mpf_get_d_2exp**`(signed long int *`

¶`exp`, const mpf_t`op`) Convert

`op`to a`double`

, truncating if necessary (i.e. rounding towards zero), and with an exponent returned separately.The return value is in the range

*0.5<=abs(*and the exponent is stored to`d`)<1`*`

.`exp`is the (truncated)`d`* 2^`exp``op`value. If`op`is zero, the return is*0.0*and 0 is stored to`*`

.`exp`This is similar to the standard C

`frexp`

function (see Normalization Functions in The GNU C Library Reference Manual).

- Function:
`long`

**mpf_get_si**`(const mpf_t`

¶`op`) - Function:
`unsigned long`

**mpf_get_ui**`(const mpf_t`

¶`op`) Convert

`op`to a`long`

or`unsigned long`

, truncating any fraction part. If`op`is too big for the return type, the result is undefined.See also

`mpf_fits_slong_p`

and`mpf_fits_ulong_p`

(see Miscellaneous Functions).

- Function:
`char *`

**mpf_get_str**`(char *`

¶`str`, mp_exp_t *`expptr`, int`base`, size_t`n_digits`, const mpf_t`op`) Convert

`op`to a string of digits in base`base`. The base argument may vary from 2 to 62 or from −2 to −36. Up to`n_digits`digits will be generated. Trailing zeros are not returned. No more digits than can be accurately represented by`op`are ever generated. If`n_digits`is 0 then that accurate maximum number of digits are generated.For

`base`in the range 2..36, digits and lower-case letters are used; for −2..−36, digits and upper-case letters are used; for 37..62, digits, upper-case letters, and lower-case letters (in that significance order) are used.If

`str`is`NULL`

, the result string is allocated using the current allocation function (see Custom Allocation). The block will be`strlen(str)+1`

bytes, that being exactly enough for the string and null-terminator.If

`str`is not`NULL`

, it should point to a block ofbytes, that being enough for the mantissa, a possible minus sign, and a null-terminator. When`n_digits`+ 2`n_digits`is 0 to get all significant digits, an application won’t be able to know the space required, and`str`should be`NULL`

in that case.The generated string is a fraction, with an implicit radix point immediately to the left of the first digit. The applicable exponent is written through the

`expptr`pointer. For example, the number 3.1416 would be returned as string`"31416"`

and exponent 1.When

`op`is zero, an empty string is produced and the exponent returned is 0.A pointer to the result string is returned, being either the allocated block or the given

`str`.