Home Library Learn Downloads Support Community
Sign in | United States - English | |
1 out of 1 rated this helpful - Rate this topic

modf, modff

Visual Studio 2010

Splits a floating-point value into fractional and integer parts.

Copy 
double modf(
   double x,
   double *intptr 
);
float modf(
   float x,
   float *intptr
);  // C++ only
long double modf(
   long double x,
   long double * intptr
);  // C++ only
float modff(
   float x,
   float *intptr 
);
x

Floating-point value.

intptr

Pointer to stored integer portion.

This function returns the signed fractional portion of x. There is no error return.

The modf function breaks down the floating-point value x into fractional and integer parts, each of which has the same sign as x. The signed fractional portion of x is returned. The integer portion is stored as a floating-point value at intptr.

modf has an implementation that uses Streaming SIMD Extensions 2 (SSE2). See _set_SSE2_enable for information and restrictions on using the SSE2 implementation.

C++ allows overloading, so you can call overloads of modf. In a C program, modf always takes two double values and returns a double value.

Routine

Required header

modf, modff

<math.h>

For additional compatibility information, see Compatibility in the Introduction.

Libraries

All versions of the C run-time libraries.

Copy 
// crt_modf.c

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

int main( void )
{
   double x, y, n;

   x = -14.87654321;      /* Divide x into its fractional */
   y = modf( x, &n );     /* and integer parts            */

   printf( "For %f, the fraction is %f and the integer is %.f\n", 
           x, y, n );
}
Copy 
For -14.876543, the fraction is -0.876543 and the integer is -14
Did you find this helpful?
(1500 characters remaining)
Community Content Add
Annotations FAQ
modff generate memory corruption in 32bit
In newer math.h (VS8, VS10, WinDDK6000, ...) modff is implemented with a bogus C macro for x86.

#define modff(x,y) ((float)modf((double)(x), (double *)(y)))

Older math.h (VC98, WinDDK3790) use a proper inline function.

inline float modff(float _X, float *_Y)
{ double _Di, _Df = modf((double)_X, &_Di);
*_Y = (float)_Di;
return ((float)_Df); }

Beside the memory corruption also the data alignment may be worse.
History