Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/numeric/math/ceil"

From cppreference.com
< cpp‎ | numeric‎ | math
m (→‎External links: ~{eli})
(Applied P1467R9.)
Line 3: Line 3:
 
{{dcl begin}}
 
{{dcl begin}}
 
{{dcl header|cmath}}
 
{{dcl header|cmath}}
−
{{dcl|num=1|notes={{mark|constexpr since C++23}}|
+
{{dcl rev multi|num=1|dcl1=
−
float      ceil ( float arg );
+
float      ceil ( float num );
 +
double      ceil ( double num );
 +
long double ceil ( long double num );
 +
|since2=c++23|dcl2=
 +
constexpr /* floating-point-type */
 +
            ceil ( /* floating-point-type */ num );
 
}}
 
}}
−
{{dcl|num=2|notes={{mark|constexpr since C++23}}|since=c++11|
+
{{dcl|num=2|since=c++11|notes={{mark|constexpr since C++23}}|
−
float      ceilf( float arg );
+
float      ceilf( float num );
 
}}
 
}}
−
{{dcl|num=3|notes={{mark|constexpr since C++23}}|
+
{{dcl|num=3|since=c++11|notes={{mark|constexpr since C++23}}|
−
double     ceil ( double arg );
+
long double ceill( long double num );
 
}}
 
}}
−
{{dcl|num=4|notes={{mark|constexpr since C++23}}|
+
{{dcl h|[[#Notes|Additional overloads]] {{mark since c++11}}}}
−
long double ceil ( long double arg );
+
{{dcl header|cmath}}
−
}}
+
{{dcl|num=A|notes={{mark|constexpr since C++23}}|
−
{{dcl|num=5|notes={{mark|constexpr since C++23}}|since=c++11|
+
template< class Integer >
−
long double ceill( long double arg );
+
double      ceil ( Integer num );
−
}}
+
−
{{dcl|num=6|notes={{mark|constexpr since C++23}}|since=c++11|
+
−
double      ceil ( IntegralType arg );
+
 
}}
 
}}
 
{{dcl end}}
 
{{dcl end}}
  
−
@1-5@ Computes the smallest integer value not less than {{tt|arg}}.
+
@1-3@ Computes the smallest integer value not less than {{c|num}}.
−
@6@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to {{v|3}} (the argument is cast to {{c|double}}).
+
 
 +
{{rrev|since=c++11|
 +
@A@ Additional overloads are provided for all integer types, which are treated as {{c/core|double}}.
 +
}}
  
 
===Parameters===
 
===Parameters===
 
{{par begin}}
 
{{par begin}}
−
{{par|arg|floating point value}}
+
{{par|num|floating point or integer value}}
 
{{par end}}
 
{{par end}}
  
 
===Return value===
 
===Return value===
−
If no errors occur, the smallest integer value not less than {{tt|arg}}, that is {{math|⌈arg⌉}}, is returned.
+
If no errors occur, the smallest integer value not less than {{c|num}}, that is {{math|⌈num⌉}}, is returned.
  
−
{{plot|left=Return value|bottom=Argument|math-ceil.svg}}
+
{{plot|left=Return value|bottom={{c|num}}|math-ceil.svg}}
  
 
===Error handling===
 
===Error handling===
Line 41: Line 46:
 
If the implementation supports IEEE floating-point arithmetic (IEC 60559),
 
If the implementation supports IEEE floating-point arithmetic (IEC 60559),
 
* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
 
* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
−
* If {{tt|arg}} is ±∞, it is returned unmodified
+
* If {{c|num}} is ±∞, it is returned unmodified
−
* If {{tt|arg}} is ±0, it is returned, unmodified
+
* If {{c|num}} is ±0, it is returned, unmodified
−
* If arg is NaN, NaN is returned
+
* If {{c|num}} is NaN, NaN is returned
  
 
===Notes===
 
===Notes===
−
{{lc|FE_INEXACT}} may be (but isn't required to be) raised when rounding a non-integer finite value.
+
{{lc|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 {{lc|std::intmax_t}}), when stored in an integer variable. It is for this reason that the return type is floating-point not integral.
 
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 {{lc|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 {{lc|FE_INEXACT}}) implemented by the following code:
+
This function (for {{c/core|double}} argument) behaves as if (except for the freedom to not raise {{lc|FE_INEXACT}}) implemented by the following code:
−
 
+
 
{{source|1=
 
{{source|1=
−
#include <cmath>
 
 
#include <cfenv>
 
#include <cfenv>
 +
#include <cmath>
 +
 
#pragma STDC FENV_ACCESS ON
 
#pragma STDC FENV_ACCESS ON
  
Line 66: Line 71:
 
}
 
}
 
}}
 
}}
 +
 +
{{cpp/numeric/math/additional integer overload note|ceil}}
  
 
===Example===
 
===Example===

Revision as of 19:26, 16 March 2023

 
C++
 
Numerics library
Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Basic linear algebra algorithms (C++26)
Floating-point environment (C++11)
Complex numbers
Numeric array (valarray)
Pseudo-random number generation
Factor operations
(C++17)
(C++17)
Interpolations
(C++20)
(C++20)
Saturation arithmetic
(C++26)
(C++26)
(C++26)
(C++26)
(C++26)

Generic numeric operations
Bit operations
(C++20)    
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++23)
(C++20)
 
Common mathematical functions
Functions
Basic operations
(C++11)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
Exponential functions
(C++11)
(C++11)

(C++11)
(C++11)
Power functions
(C++11)
(C++11)
Trigonometric and
hyperbolic functions
(C++11)
(C++11)
(C++11)

Error and gamma functions
(C++11)
(C++11)
(C++11)
(C++11)
Nearest integer floating point operations
ceil
(C++11)(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
Floating point manipulation functions
(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
 
Defined in header <cmath>
(1)
float       ceil ( float num );

double      ceil ( double num );

long double ceil ( long double num );
 (until C++23)
constexpr /* floating-point-type */
            ceil ( /* floating-point-type */ num );
 (since C++23)
float       ceilf( float num );
 (2) (since C++11)
(constexpr since C++23)
long double ceill( long double num );
 (3) (since C++11)
(constexpr since C++23)
Additional overloads (since C++11)
Defined in header <cmath>
template< class Integer >
double      ceil ( Integer num );
 (A) (constexpr since C++23)
1-3) Computes the smallest integer value not less than num.
A) Additional overloads are provided for all integer types, which are treated as double.
 (since C++11)

Contents

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.

Return value
math-ceil.svg
num

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 (A). 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)).

Example

Run this code
#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';
}

Output: 

ceil(+2.4) = 3.000000
ceil(-2.4) = -2.000000
ceil(-0.0) = -0.000000
ceil(-Inf) = -inf

See also

(C++11)(C++11)
 nearest integer not greater than the given value
(function) [edit]
(C++11)(C++11)(C++11)
 nearest integer not greater in magnitude than the given value
(function) [edit]
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
 nearest integer, rounding away from zero in halfway cases
(function) [edit]
(C++11)(C++11)(C++11)
 nearest integer using current rounding mode
(function) [edit]
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
 nearest integer using current rounding mode with
exception if the result differs
(function) [edit]
C documentation for ceil

External links

Fast ceiling of an integer division — StackOverflow
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/math/ceil&oldid=149197"