Defined in header
floatfmod(floatx,floaty);doublefmod(doublex,doubley);longdoublefmod(longdoublex,longdoubley); (1)(until C++23)constexpr/*floating-point-type*/fmod(/*floating-point-type*/x,/*floating-point-type*/y);(since C++23)floatfmodf(floatx,floaty); (2)(since C++11)
(constexpr since C++23)longdoublefmodl(longdoublex,longdoubley); (3)(since C++11)
(constexpr since C++23)
(since C++26)
Defined in header
template<classV0,classV1>constexpr/*math-common-simd-t*/<V0,V1>fmod(constV0&v_x,constV1&v_y); (S) (since C++26)
(since C++11)
Defined in header
template<classInteger>doublefmod(Integerx,Integery); (A)(constexpr since C++23)1-3) Computes the floating-point remainder of the division operation x/y. The library provides overloads of std::fmod for all cv-unqualified floating-point types as the type of the parameters.(since C++23)
S) The SIMD overload performs an element-wise std::fmod on v_xand v_y.
(See
for its definition.)(since C++26)A) Additional overloads are provided for all integer types, which are treated as double.
(since C++11)The floating-point remainder of the division operation x/y calculated by this function is exactly the value x-iquot*y, where iquot is x/y with its fractional part truncated.
The returned value has the same sign as x and is less than y in magnitude.
Parameters
x, y - floating-point or integer values Return value
If successful, returns the floating-point remainder of the division x/y as defined above.
If a domain error occurs, an implementation-defined value is returned (NaN where supported).
If a range error occurs due to underflow, the correct result (after rounding) is returned.
Error handling
Errors are reported as specified in
.
Domain error may occur if y is zero.
If the implementation supports IEEE floating-point arithmetic (IEC 60559),
If x is ±0 and y is not zero, ±0 is returned.
If x is ±∞ and y is not NaN, NaN is returned and
is raised.
If y is ±0 and x is not NaN, NaN is returned and
is raised.
If y is ±∞ and x is finite, x is returned.
If either argument is NaN, NaN is returned.
Notes
that a domain error occurs if x is infinite or y is zero.
std::fmod, but not
is useful for doing silent wrapping of floating-point types to unsigned integer types: (0.0<=(y=std::fmod(std::rint(x),65536.0))?y:65536.0+y) is in the range [-0.0, 65535.0], which corresponds to unsignedshort, but std::remainder(std::rint(x),65536.0 is in the range [-32767.0, +32768.0], which is outside of the range of signedshort.
The double version of std::fmod behaves as if implemented as follows:
doublefmod(doublex,doubley){#pragma STDC FENV_ACCESS ONdoubleresult=std::remainder(std::fabs(x),y=std::fabs(y));if(std::signbit(result))result+=y;returnstd::copysign(result,x);}The expression x-std::trunc(x/y)*y may not equal std::fmod(x,y), when the rounding of x/y to initialize the argument of
loses too much precision (example: x=30.508474576271183309, y=6.1016949152542370172).
The additional overloads are not required to be provided exactly as (A). They only need to be sufficient to ensure that for their first argument num1 and second argument num2:
If num1 or num2 has type longdouble, then std::fmod(num1,num2) has the same effect as std::fmod(static_cast<longdouble>(num1),
static_cast<longdouble>(num2)).
Otherwise, if num1 and/or num2 has type double or an integer type, then std::fmod(num1,num2) has the same effect as std::fmod(static_cast<double>(num1),
static_cast<double>(num2)).
Otherwise, if num1 or num2 has type float, then std::fmod(num1,num2) has the same effect as std::fmod(static_cast<float>(num1),
static_cast<float>(num2)).
(until C++23)If num1 and num2 have arithmetic types, then std::fmod(num1,num2) has the same effect as std::fmod(static_cast</*common-floating-point-type*/>(num1),
static_cast</*common-floating-point-type*/>(num2)), where /*common-floating-point-type*/ is the floating-point type with the greatest
floating-point conversion rank
and greatest
floating-point conversion subrank
between the types of num1 and num2, arguments of integer type are considered to have the same floating-point conversion rank as double.
If no such floating-point type with the greatest rank and subrank exists, then
does not result in a usable candidate from the overloads provided.
(since C++23)Example
Run this code
#include<cfenv>#include<cmath>#include<iostream>// #pragma STDC FENV_ACCESS ONintmain(){std::cout<<"fmod(+5.1, +3.0) = "<<std::fmod(5.1,3)<<'\n'<<"fmod(-5.1, +3.0) = "<<std::fmod(-5.1,3)<<'\n'<<"fmod(+5.1, -3.0) = "<<std::fmod(5.1,-3)<<'\n'<<"fmod(-5.1, -3.0) = "<<std::fmod(-5.1,-3)<<'\n';// special valuesstd::cout<<"fmod(+0.0, 1.0) = "<<std::fmod(0,1)<<'\n'<<"fmod(-0.0, 1.0) = "<<std::fmod(-0.0,1)<<'\n'<<"fmod(5.1, Inf) = "<<std::fmod(5.1,INFINITY)<<'\n';// error handlingstd::feclearexcept(FE_ALL_EXCEPT);std::cout<<"fmod(+5.1, 0) = "<<std::fmod(5.1,0)<<'\n';if(std::fetestexcept(FE_INVALID))std::cout<<" FE_INVALID raised\n";}Possible output:
fmod(+5.1, +3.0) = 2.1 fmod(-5.1, +3.0) = -2.1 fmod(+5.1, -3.0) = 2.1 fmod(-5.1, -3.0) = -2.1 fmod(+0.0, 1.0) = 0 fmod(-0.0, 1.0) = -0 fmod(5.1, Inf) = 5.1 fmod(+5.1, 0) = -nan FE_INVALID raised See also