Next: Assigning Floats, Previous: Floating-point Functions, Up: Floating-point Functions [Index]

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

Next: Assigning Floats, Previous: Floating-point Functions, Up: Floating-point Functions [Index]