- Function:
`void`

**mpf_set_default_prec**`(mp_bitcnt_t`

¶`prec`) Set the default precision to be

**at least**`prec`bits. All subsequent calls to`mpf_init`

will use this precision, but previously initialized variables are unaffected.

- Function:
`mp_bitcnt_t`

**mpf_get_default_prec**`(void)`

¶ Return the default precision actually used.

An `mpf_t`

object must be initialized before storing the first value in
it. The functions `mpf_init`

and `mpf_init2`

are used for that
purpose.

- Function:
`void`

**mpf_init**`(mpf_t`

¶`x`) Initialize

`x`to 0. Normally, a variable should be initialized once only or at least be cleared, using`mpf_clear`

, between initializations. The precision of`x`is undefined unless a default precision has already been established by a call to`mpf_set_default_prec`

.

- Function:
`void`

**mpf_init2**`(mpf_t`

¶`x`, mp_bitcnt_t`prec`) Initialize

`x`to 0 and set its precision to be**at least**`prec`bits. Normally, a variable should be initialized once only or at least be cleared, using`mpf_clear`

, between initializations.

- Function:
`void`

**mpf_inits**`(mpf_t`

¶`x`, ...) Initialize a NULL-terminated list of

`mpf_t`

variables, and set their values to 0. The precision of the initialized variables is undefined unless a default precision has already been established by a call to`mpf_set_default_prec`

.

- Function:
`void`

**mpf_clear**`(mpf_t`

¶`x`) Free the space occupied by

`x`. Make sure to call this function for all`mpf_t`

variables when you are done with them.

- Function:
`void`

**mpf_clears**`(mpf_t`

¶`x`, ...) Free the space occupied by a NULL-terminated list of

`mpf_t`

variables.

Here is an example on how to initialize floating-point variables:

{ mpf_t x, y; mpf_init (x); /* use default precision */ mpf_init2 (y, 256); /* precisionat least256 bits */ … /* Unless the program is about to exit, do ... */ mpf_clear (x); mpf_clear (y); }

The following three functions are useful for changing the precision during a calculation. A typical use would be for adjusting the precision gradually in iterative algorithms like Newton-Raphson, making the computation precision closely match the actual accurate part of the numbers.

- Function:
`mp_bitcnt_t`

**mpf_get_prec**`(const mpf_t`

¶`op`) Return the current precision of

`op`, in bits.

- Function:
`void`

**mpf_set_prec**`(mpf_t`

¶`rop`, mp_bitcnt_t`prec`) Set the precision of

`rop`to be**at least**`prec`bits. The value in`rop`will be truncated to the new precision.This function requires a call to

`realloc`

, and so should not be used in a tight loop.

- Function:
`void`

**mpf_set_prec_raw**`(mpf_t`

¶`rop`, mp_bitcnt_t`prec`) Set the precision of

`rop`to be**at least**`prec`bits, without changing the memory allocated.`prec`must be no more than the allocated precision for`rop`, that being the precision when`rop`was initialized, or in the most recent`mpf_set_prec`

.The value in

`rop`is unchanged, and in particular if it had a higher precision than`prec`it will retain that higher precision. New values written to`rop`will use the new`prec`.Before calling

`mpf_clear`

or the full`mpf_set_prec`

, another`mpf_set_prec_raw`

call must be made to restore`rop`to its original allocated precision. Failing to do so will have unpredictable results.`mpf_get_prec`

can be used before`mpf_set_prec_raw`

to get the original allocated precision. After`mpf_set_prec_raw`

it reflects the`prec`value set.`mpf_set_prec_raw`

is an efficient way to use an`mpf_t`

variable at different precisions during a calculation, perhaps to gradually increase precision in an iteration, or just to use various different precisions for different purposes during a calculation.