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

Latest revision as of 21:28, 15 October 2023

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 least 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.(since C++23)

A) Additional overloads are provided for all integer types, which are treated as double.

(since C++11)

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

[edit] 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

[edit] See also

floorfloorffloorl (C++11)(C++11)	nearest integer not greater than the given value (function) [edit]
trunctruncftruncl (C++11)(C++11)(C++11)	nearest integer not greater in magnitude than the given value (function) [edit]
roundroundfroundllroundlroundflroundlllroundllroundfllroundl (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]
nearbyintnearbyintfnearbyintl (C++11)(C++11)(C++11)	nearest integer using current rounding mode (function) [edit]
rintrintfrintllrintlrintflrintlllrintllrintfllrintl (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

[edit] External links

Fast ceiling of an integer division — StackOverflow

@@ Line 1: / Line 1: @@
-{{cpp/title|ceil}}
+{{cpp/title|ceil|ceilf|ceill}}
-{{cpp/numeric/math/sidebar}}
+{{cpp/numeric/math/navbar}}
-{{ddcl list begin}}
+{{cpp/numeric/math/declarations
-{{ddcl list header | cmath}}
+|family=ceil
-{{ddcl list item |
+|param1=num
-float       ceil( float arg );
+|constexpr_since=23
+|desc=Computes the least integer value not less than {{c|num}}.
 }}
-{{ddcl list item |
-double      ceil( double arg );
-}}
-{{ddcl list item |
-long double ceil( long double arg );
-}}
-{{ddcl list item | notes={{mark since c++11}} |
-double      ceil( Integral arg );
-}}
-{{ddcl list end}}
-Computes nearest integer not less than {{tt|arg}}.
 ===Parameters===
-{{param list begin}}
+{{par begin}}
-{{param list item | arg | floating point value}}
+{{par|num|floating point or integer value}}
-{{param list end}}
+{{par end}}
 ===Return value===
-Nearest integer not less than {{tt|arg}}
+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" | image=math-ceil.svg}}
+{{plot|left=Return value|bottom={{c|num}}|math-ceil.svg}}
+===Error handling===
+Errors are reported as specified in {{lc|math_errhandling}}.
+If the implementation supports IEEE floating-point arithmetic (IEC 60559),
+* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
+* If {{c|num}} is ±∞, it is returned unmodified.
+* If {{c|num}} is ±0, it is returned, unmodified.
+* If {{c|num}} is NaN, NaN is returned.
 ===Notes===
-The integer value can be always represented by the given floating point type.
+{{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.
+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=
+#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;
+}
+}}
+{{cpp/numeric/math/additional integer overload note|ceil}}
 ===Example===
 {{example
- | code=
+|code=
 #include <cmath>
 #include <iostream>
 int main()
 {
-    double a = 12.0;
+     std::cout << std::fixed
-     std::cout << std::fixed;
+              << "ceil(+2.4) = " << std::ceil(+2.4) << '\n'
-    std::cout << std::ceil(12.0) << '\n';
+              << "ceil(-2.4) = " << std::ceil(-2.4) << '\n'
-    std::cout << std::ceil(12.1) << '\n';
+              << "ceil(-0.0) = " << std::ceil(-0.0) << '\n'
-    std::cout << std::ceil(12.5) << '\n';
+              << "ceil(-Inf) = " << std::ceil(-INFINITY) << '\n';
-    std::cout << std::ceil(12.9) << '\n';
+}
-    std::cout << std::ceil(13.0) << '\n';}
+|output=
- | output=
+ceil(+2.4) = 3.000000
-.000000
+ceil(-2.4) = -2.000000
-.000000
+ceil(-0.0) = -0.000000
-.000000
+ceil(-Inf) = -inf
-.000000
-.000000
 }}
 ===See also===
+{{dsc begin}}
+{{dsc inc|cpp/numeric/math/dsc floor}}
+{{dsc inc|cpp/numeric/math/dsc trunc}}
+{{dsc inc|cpp/numeric/math/dsc round}}
+{{dsc inc|cpp/numeric/math/dsc nearbyint}}
+{{dsc inc|cpp/numeric/math/dsc rint}}
+{{dsc see c|c/numeric/math/ceil}}
+{{dsc end}}
+===External links===
+{{eli|[https://stackoverflow.com/a/2745086 Fast ceiling of an integer division] &mdash; StackOverflow}}
-{{dcl list begin}}
+{{langlinks|de|es|fr|it|ja|pl|pt|ru|zh}}
-{{dcl list template | cpp/numeric/math/dcl list floor}}
-{{dcl list template | cpp/numeric/math/dcl list trunc}}
-{{dcl list template | cpp/numeric/math/dcl list round}}
-{{dcl list end}}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.com

Namespaces

Variants

Views

Actions

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

Latest revision as of 21:28, 15 October 2023

Contents

[edit] Parameters

[edit] Return value

[edit] Error handling

[edit] Notes

[edit] Example

[edit] See also

[edit] External links

Navigation

Toolbox