Initializing Floats (GNU MP 6.3.0)
Description: How to install and use the GNU multiple precision arithmetic library, version 6.3.0.

### 7.1 Initialization Functions ¶

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);     /* precision at least 256 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.