Ceil
Defined in header <cmath>
.
Description
Computes the smallest integer value not less than num
.
The library provides overloads of std::ceil for all cv-unqualified floating-point types as the type of the parameter num
(od C++23).
Additional overloads are provided for all integer types, which are treated as double (od C++11).
Declarations
- C++23
- C++11
// 1)
constexpr /* floating-point-type */ ciel( /* floating-point-type */ num );
// 2)
constexpr float cielf( float num );
// 3)
constexpr long double ciell( long double num );
// 4)
template< class Integer >
constexpr double ciel ( Integer num );
// 1)
float ciel ( float num );
// 2)
double ciel ( double num );
//3)
long double ciel ( long double num );
// 4)
float erfcf( float num );
// 5)
long double erfcl( long double num );
// 6)
template< class Integer >
double ciel ( Integer num );
Parameters
num
- floating point or integer value
Return value
If no errors occur, the smallest integer value not less than num
, that is ⌈num⌉, is returned.
Error handling
Errors are reported as specified in math_errhandling.
If the implementation supports IEEE floating-point arithmetic (IEC 60559):
The current rounding mode has no effect.
If num is ±∞
, it is returned unmodified
If num is ±0
, it is returned, unmodified
If num is NaN, NaN is returned
Notes
FE_INEXACT may be (but is not required to be) raised when rounding a non-integer finite value.
The largest representable floating-point values are exact integers in all standard floating-point formats,
so this function never overflows on its own; however the result may overflow any integer type (including std::intmax_t
),
when stored in an integer variable. It is for this reason that the return type is floating-point not integral.
This function (for double argument) behaves as if (except for the freedom to not raise FE_INEXACT) implemented by the following code:
#include <cfenv>
#include <cmath>
#pragma STDC FENV_ACCESS ON
double ceil(double x)
{
int save_round = std::fegetround();
std::fesetround(FE_UPWARD);
double result = std::rint(x); // or std::nearbyint
std::fesetround(save_round);
return result;
}
The additional overloads are not required to be provided exactly as Additional Overloads.
They only need to be sufficient to ensure that for their argument num
of integer type,
std::ceil(num)
has the same effect as std::ceil(static_cast<double>(num))
.
Examples
#include <cmath>
#include <iostream>
int main()
{
std::cout
<< std::fixed
<< "ceil(+2.4) = "
<< std::ceil(+2.4) << '\n'
<< "ceil(-2.4) = "
<< std::ceil(-2.4) << '\n'
<< "ceil(-0.0) = "
<< std::ceil(-0.0) << '\n'
<< "ceil(-Inf) = "
<< std::ceil(-INFINITY) << '\n';
}
ceil(+2.4) = 3.000000
ceil(-2.4) = -2.000000
ceil(-0.0) = -0.000000
ceil(-Inf) = -inf