##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# modf, modff, modfl

From cppreference.com
< c‎ | numeric‎ | math

Defined in header `<math.h>` |  |
float modff( float arg, float* iptr ); | (1) | (since C99)
double modf( double arg, double* iptr ); | (2) |
long double modfl( long double arg, long double* iptr ); | (3) | (since C99)

1-3) Decomposes given floating point value `arg` into integral and fractional parts, each having the same type and sign as `arg`. The integral part (in floating-point format) is stored in the object pointed to by `iptr`.

### [edit] Parameters

arg | - | floating point value
iptr | - | pointer to floating point value to store the integral part to

### [edit] Return value

If no errors occur, returns the fractional part of `x` with the same sign as `x`. The integral part is put into the value pointed to by `iptr`.

The sum of the returned value and the value stored in `*iptr` gives `arg` (allowing for rounding).

### [edit] Error handling

This function is not subject to any errors specified in math_errhandling.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

- If `arg` is ±0, ±0 is returned, and ±0 is stored in *iptr.
- If `arg` is ±∞, ±0 is returned, and ±∞ is stored in *iptr.
- If `arg` is NaN, NaN is returned, and NaN is stored in *iptr.
- The returned value is exact, the current rounding mode is ignored

### [edit] Notes

This function behaves as if implemented as follows:

    double modf(double value, double *iptr)
    {
    #pragma STDC FENV_ACCESS ON
        int save_round = fegetround();
        fesetround(FE_TOWARDZERO);
        *iptr = std::nearbyint(value);
        fesetround(save_round);
        return copysign(isinf(value) ? 0.0 : value - (*iptr), value);
    }

### [edit] Example

Run this code

    #include <stdio.h>
    #include <math.h>
    #include <float.h>

    int main(void)
    {
        double f = 123.45;
        printf("Given the number %.2f or %a in hex,\n", f, f);

        double f3;
        double f2 = modf(f, &f3);
        printf("modf() makes %.2f + %.2f\n", f3, f2);

        int i;
        f2 = frexp(f, &i);
        printf("frexp() makes %f * 2^%d\n", f2, i);

        i = ilogb(f);
        printf("logb()/ilogb() make %f * %d^%d\n", f/scalbn(1.0, i), FLT_RADIX, i);

        // special values
        f2 = modf(-0.0, &f3);
        printf("modf(-0) makes %.2f + %.2f\n", f3, f2);
        f2 = modf(-INFINITY, &f3);
        printf("modf(-Inf) makes %.2f + %.2f\n", f3, f2);
    }

Possible output:

    Given the number 123.45 or 0x1.edccccccccccdp+6 in hex,
    modf() makes 123.00 + 0.45
    frexp() makes 0.964453 * 2^7
    logb()/ilogb() make 1.92891 * 2^6
    modf(-0) makes -0.00 + -0.00
    modf(-Inf) makes -INF + -0.00

### [edit] References

- C11 standard (ISO/IEC 9899:2011):

  - 7.12.6.12 The modf functions (p: 246-247)

  - F.10.3.12 The modf functions (p: 523)

- C99 standard (ISO/IEC 9899:1999):

  - 7.12.6.12 The modf functions (p: 227)

  - F.9.3.12 The modf functions (p: 460)

- C89/C90 standard (ISO/IEC 9899:1990):

  - 4.5.4.6 The modf function

### [edit] See also

trunc truncf truncl (C99)(C99)(C99) | rounds to nearest integer not greater in magnitude than the given value (function) [edit]
C++ documentation for modf

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=c/numeric/math/modf&oldid=78889"