Namespaces
Variants
Views
Actions

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

From cppreference.com
< cpp‎ | numeric‎ | math
(Link to fast ceiling of an integer division discussion)
m (→‎External links: ~{eli})
Line 2: Line 2:
 
{{cpp/numeric/math/navbar}}
 
{{cpp/numeric/math/navbar}}
 
{{dcl begin}}
 
{{dcl begin}}
−
{{dcl header | cmath}}
+
{{dcl header|cmath}}
−
{{dcl |num=1|notes={{mark|constexpr since C++23}}|
+
{{dcl|num=1|notes={{mark|constexpr since C++23}}|
 
float      ceil ( float arg );
 
float      ceil ( float arg );
 
}}
 
}}
−
{{dcl |num=2|notes={{mark|constexpr since C++23}}|since=c++11|
+
{{dcl|num=2|notes={{mark|constexpr since C++23}}|since=c++11|
 
float      ceilf( float arg );
 
float      ceilf( float arg );
 
}}
 
}}
−
{{dcl |num=3|notes={{mark|constexpr since C++23}}|
+
{{dcl|num=3|notes={{mark|constexpr since C++23}}|
 
double      ceil ( double arg );
 
double      ceil ( double arg );
 
}}
 
}}
−
{{dcl |num=4|notes={{mark|constexpr since C++23}}|
+
{{dcl|num=4|notes={{mark|constexpr since C++23}}|
 
long double ceil ( long double arg );
 
long double ceil ( long double arg );
 
}}
 
}}
−
{{dcl |num=5|notes={{mark|constexpr since C++23}}|since=c++11|
+
{{dcl|num=5|notes={{mark|constexpr since C++23}}|since=c++11|
 
long double ceill( long double arg );
 
long double ceill( long double arg );
 
}}
 
}}
−
{{dcl |num=6|notes={{mark|constexpr since C++23}}|since=c++11|
+
{{dcl|num=6|notes={{mark|constexpr since C++23}}|since=c++11|
 
double      ceil ( IntegralType arg );
 
double      ceil ( IntegralType arg );
 
}}
 
}}
 
{{dcl end}}
 
{{dcl end}}
  
−
@1-5@ Computes the smallest integer value not less than {{tt|arg}}.  
+
@1-5@ Computes the smallest integer value not less than {{tt|arg}}.
 
@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}}).
 
@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}}).
  
 
===Parameters===
 
===Parameters===
 
{{par begin}}
 
{{par begin}}
−
{{par | arg | floating point value}}
+
{{par|arg|floating point value}}
 
{{par end}}
 
{{par end}}
  
Line 34: Line 34:
 
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 {{tt|arg}}, that is {{math|⌈arg⌉}}, is returned.
  
−
{{plot | left=Return value | bottom=Argument | math-ceil.svg}}
+
{{plot|left=Return value|bottom=Argument|math-ceil.svg}}
  
 
===Error handling===
 
===Error handling===
Line 52: Line 52:
 
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 double argument) behaves as if (except for the freedom to not raise {{lc|FE_INEXACT}}) implemented by the following code:
  
−
{{source|1=#include <cmath>
+
{{source|1=
 +
#include <cmath>
 
#include <cfenv>
 
#include <cfenv>
 
#pragma STDC FENV_ACCESS ON
 
#pragma STDC FENV_ACCESS ON
 +
 
double ceil(double x)
 
double ceil(double x)
 
{
 
{
 
     int save_round = std::fegetround();
 
     int save_round = std::fegetround();
 
     std::fesetround(FE_UPWARD);
 
     std::fesetround(FE_UPWARD);
−
     double result = std::rint(x); // or std::nearbyint  
+
     double result = std::rint(x); // or std::nearbyint
 
     std::fesetround(save_round);
 
     std::fesetround(save_round);
 
     return result;
 
     return result;
Line 67: Line 69:
 
===Example===
 
===Example===
 
{{example
 
{{example
−
| code=
+
|code=
 
#include <cmath>
 
#include <cmath>
 
#include <iostream>
 
#include <iostream>
 +
 
int main()
 
int main()
 
{
 
{
Line 78: Line 81:
 
               << "ceil(-Inf) = " << std::ceil(-INFINITY) << '\n';
 
               << "ceil(-Inf) = " << std::ceil(-INFINITY) << '\n';
 
}
 
}
−
| output=
+
|output=
 
ceil(+2.4) = 3.000000
 
ceil(+2.4) = 3.000000
 
ceil(-2.4) = -2.000000
 
ceil(-2.4) = -2.000000
Line 87: Line 90:
 
===See also===
 
===See also===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/numeric/math/dsc floor}}
+
{{dsc inc|cpp/numeric/math/dsc floor}}
−
{{dsc inc | cpp/numeric/math/dsc trunc}}
+
{{dsc inc|cpp/numeric/math/dsc trunc}}
−
{{dsc inc | cpp/numeric/math/dsc round}}
+
{{dsc inc|cpp/numeric/math/dsc round}}
−
{{dsc inc | cpp/numeric/math/dsc nearbyint}}
+
{{dsc inc|cpp/numeric/math/dsc nearbyint}}
−
{{dsc inc | cpp/numeric/math/dsc rint}}
+
{{dsc inc|cpp/numeric/math/dsc rint}}
−
{{dsc see c | c/numeric/math/ceil}}
+
{{dsc see c|c/numeric/math/ceil}}
 
{{dsc end}}
 
{{dsc end}}
 +
 +
===External links===
 +
{{eli|[https://stackoverflow.com/a/2745086 Fast ceiling of an integer division] &mdash; StackOverflow}}
  
 
{{langlinks|de|es|fr|it|ja|pl|pt|ru|zh}}
 
{{langlinks|de|es|fr|it|ja|pl|pt|ru|zh}}
−
 
−
===See also===
 
−
[https://stackoverflow.com/a/2745086 Fast ceiling of an integer division]
 

Revision as of 14:47, 9 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>
float       ceil ( float arg );
 (1) (constexpr since C++23)
float       ceilf( float arg );
 (2) (since C++11)
(constexpr since C++23)
double      ceil ( double arg );
 (3) (constexpr since C++23)
long double ceil ( long double arg );
 (4) (constexpr since C++23)
long double ceill( long double arg );
 (5) (since C++11)
(constexpr since C++23)
double      ceil ( IntegralType arg );
 (6) (since C++11)
(constexpr since C++23)
1-5) Computes the smallest integer value not less than arg.
6) A set of overloads or a function template accepting an argument of any integral type. Equivalent to (3) (the argument is cast to double).

Contents

Parameters

arg - floating point value

Return value

If no errors occur, the smallest integer value not less than arg, that is ⌈arg⌉, is returned.

Return value
math-ceil.svg
Argument

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 arg is ±∞, it is returned unmodified
  • If arg is ±0, it is returned, unmodified
  • If arg is NaN, NaN is returned

Notes

FE_INEXACT may be (but isn't 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 <cmath>
#include <cfenv>
#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;
}

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=148952"