# floor() and ceil()  function in C++

In this article, you will learn about floor and ceil() function in C++ with their syntax, examples, applications, advantages, and disadvantages.

## floor() in C++:

In mathematics, the "ground" of an actual quantity is defined as the most significant integer this is less than or identical to that quantity. It rounds down quite a number to the nearest whole variety or integer fee.

A mathematical characteristic blanketed inside the library is called the floor(). A floating-point variety is rounded to the closest integer cost. It is either smaller than or the same as the unique value of the usage of this method. Depending on the kind of furnished argument, the characteristic returns both a double and a go-with-the-flow fee.

The floor() function in C++ provides a manner to compute the floor  value of a floating-point quantity. It is part of the <cmath> (or <math.h> in C) library, which includes various mathematical features. When you call the ground() function with a floating-factor range as its argument, it performs the subsequent steps:

1. It truncates any fractional part of the wide variety, eliminating the entirety after the decimal point.
2. It returns the most critical integer that is less than or identical to the truncated fee.

Here are a few examples to demonstrate how the floor() function works:

Floor (3.8) returns three: The fractional a part of 3.8 is 0.8, which receives truncated, ensuing in 3.

floor(-2.5) returns -3: The fractional part of -2.5 is -0.5, which receives truncated, resulting in -3.

floor(7.0) returns 7: There is no fractional part because 7.0 is already an entire quantity.

The floor() feature is handy for rounding down a floating-factor variety into an integer value. It may be helpful in diverse situations, consisting of when you need to calculate the wide variety of whole units or when you need to align values to a lower grid or scale.

It's vital to observe that the floor() expected returns a floating-factor value, even supposing the argument surpassed its miles an integer. If you mainly want an integer result, you may perform a kind conversion to transform the back value to an integer using capabilities like static_cast<int>() or by using at once assigning it to an integer variable.

Syntax:

The floor() function has the following syntax:

`#include <cmath>double floor(double x);float floor(float x);`

The single argument for the floor() method is x, the integer to be rounded down. The most significant integral number that is less than or equal to x is what is returned. The type of the return value matches that of the argument.

Program:

`#include <iostream>#include <cmath>int main() {    double numbers[] = { 5.7, -3.2, 9.0 }      for (const double number : numbers) {        double result = floor(number);            std::cout << "Original number: " << number << std::endl;        std::cout << "Rounded down value: " << result << std::endl;        std::cout << std::endl;    }    return 0;}`

Output:

`Original number: 5.7Rounded down value: 5Original number: -3.2Rounded down value: -4Original number: 9Rounded down value: 9`

Explanation:

• The code begins with the aid of together with the essential header documents: <iostream> for enter/output operations and <cmath> for the ground() function.
• An array named numbers is said, which includes three floating-point numbers: 5.7, -3.2, and 9.0.
• The for loop is used to iterate via every quantity in the numbers array.
• The variable loop range is declared a steady double, which takes on the value of every detail within the array in every generation.
• Inside the loop, the ground() function is used to spherical down the contemporary number.
• The rounded-down value is saved in the variable result.
• After that, the code prints the authentic wide variety and the rounded-down cost for every generation using std::cout.
• The authentic wide variety is printed using the line: std::cout << "Original number: " << variety << std::endl;
• The rounded-down fee as outlined in the usage of the road: std::cout << "Rounded down cost: " << result << std::endl;
• The std::endl inserts a new line after printing each set of values.
• After printing the values, an extra std::cout << std::endl; inserts a clean line for better clarity between every set of original and rounded-down values.
• Finally, the return 0; declaration is used to signify a successful program termination. When you run this code, it will iterate through each wide variety inside the numbers array and print the unique range along with its corresponding rounded-down fee. The code demonstrates the conduct of the floor() characteristic for superb, negative, and whole numbers.

## Complexity Analysis:

### Time Complexity:

• The time complexity of the floor() function itself is generally consistent with time or O(1). It plays an easy calculation to spherical down a given floating-factor variety.
• The "for loop" iterates through every range inside the numbers array. The loop will execute three times because the array has three factors, regardless of the array's size.
• Thus, the total time complexity of the code is O(1) + O(1) + O(1), which is the same as O(1).

### Space Complexity:

• The space complexity of the code is decided using the dimensions of the numbers array and the variables used inside the main() feature.
• The numbers array takes up space in memory to store the three floating-factor numbers.
• The loop variable range and the variables result occupy the area on the stack. Still, the space they devour is considered steadily because they are declared inside the loop and reused for every new release.
• Other than the array and variables, there aren't any additional facts structures or dynamic reminiscence allocations in the code.
• Therefore, the space complexity of the code is O(1), indicating constant area usage.

## Applications of floor()  in C++ :

The floor() feature in C++ has diverse applications in different domains. Here are some standard applications:

Numerical Calculations: The floor() feature is frequently utilized in numerical calculations wherein it's far more critical to spherical down floating-factor values to the closest integer. For instance, when managing monetary calculations, measurements, or any situation wherein fractional components are irrelevant, the floor() function helps ensure accurate outcomes.

Data Analysis: In records analysis or records, the ground() function may be used to discretize or bin continuous variables. By rounding down values, you could organized data into predefined periods or create histograms. It can be beneficial for visualizing and analyzing records distributions or performing certain statistical operations.

Game Development: The floor() feature is typically employed for collision detection or position calculations. It is used to align gadgets to a grid or snap them to a selected place by rounding down the coordinates. It ensures particular positioning and alignment of game factors.

Time Conversions: When working with time-associated calculations, the ground() function may be beneficial for converting time durations. For instance, if you have a time  value in seconds and want to transform it to mins, you could divide the  value utilizing b and observe the floor() to get the complete range of minutes.

Simulation and Modeling: Simulation and modeling programs regularly require rounding down values to simulate discrete events or behaviors. The floor() function ensures that values are treated as whole numbers or integers in simulations or mathematical models.

User Interfaces: In graphical user interfaces (GUI), the ground() feature may be used to decide the placement of factors at the display. You may ensure that GUI elements are displayed at pixel-best positions by rounding down floating-point coordinates.

Progress Bars and Percentage Calculations: The ground() function may round down the computed values when displaying development bars or calculating possibilities. It guarantees that development is represented correctly and that percentages are displayed as whole numbers.

Random Number Generation: In specific scenarios, random comprehensive variety technology may require rounding down floating-factor values. For example, if you need to generate random integers inside a specific variety, you could use ground() in a mixture with random vast variety turbines to obtain the desired results.

Graphics and Image Processing: In pics and picture processing packages, the floor() feature can be utilized for operations including resampling, photo scaling, or interpolation. When calculating pixel values or coordinates, rounding down ensures that the following values align with the discrete nature of photo pixels.

Optimization Algorithms: The floor() feature may constrain variables or search areas to discrete values in optimization algorithms. It facilitates discretizing continuous optimization troubles, consisting of genetic algorithms or combinatorial optimization, in which variables want to be rounded down to specific values.

Geometry and Grid-based Calculations: When managing geometric calculations or grid-based total algorithms, the floor() Function is often used to determine the nearest grid points or cellular indices. It facilitates mapping continuous coordinates to grid coordinates, enabling accurate indexing and calculations.

Simulating Integer Arithmetic: In situations where integer arithmetic is desired, the ground() feature can be used to simulate floating-factor operations. By rounding down the floating-point values, after casting them to integers, you could perform calculations just like integer mathematics.

## Advantages of the floor() function in C++:

There are various advantages of the floor() function in C++. Some main advantages of the floor() function in C++ are as follows:

Precision and Accuracy: The floor() function provides precise rounding down of floating-point numbers. It ensures that the result is an essential integer, which is much less than or equal to the input value, without any loss of precision.

Standardized Functionality: The floor() feature is a standardized mathematical characteristic to be had in the C++ language. It is a part of the standard library and can be used throughout unique structures and compilers, ensuring consistent behavior.

Simple and Efficient: The floor() feature is straightforward, requiring the handiest unmarried argument. It performs the rounding operation correctly, making it suitable for numerous applications without extensive performance overhead.

Versatility: The floor() function can cope with good and poor and real numbers. It offers bendy way to spherical down floating-factor values to the nearest integer, irrespective of their signal or fractional part.

Predictable Behaviour: The floor() function follows a nicely-defined algorithm for rounding down, ensuring steady effects throughout different inputs. It predictability is helpful when you need deterministic behavior in your code.

Confirms to Mathematical Conventions: The floor() function aligns with mathematical conventions, making it appropriate for computations and algorithms requiring rounding down. It allows you to paint with numbers in a way that corresponds to mathematical ideas.

Cross-Platform Compatibility: The floor() function is a general mathematical feature defined within the well-known C++ library. It is supported throughout extraordinary systems and compilers, ensuring code portability.

Mathematical Consistency: The floor() feature follows the mathematical conference of rounding down. It presents results constant with the mathematical definition of the floor function, making it beneficial for mathematical calculations and algorithms.

Readability and Understandability: The floor() feature has a self-descriptive call, enhancing the code's clarity and understandability. It conveys the goal to spherical down a floating-point quantity, making the code extra maintainable.

## Disadvantages of the floor() function in C++:

There are various disadvantages of the floor() function in C++. Some main disadvantages of the floor() function in C++ are as follows:

Limited Rounding Options: The floor() function completely rounds down floating-factor numbers. It no longer offers alternatives for rounding to the closest integer, rounding up, or using one-of-a-kind rounding modes. If different rounding behaviors are required, opportunity capabilities or methods want to be employed.

Incompatibility with Integer Types: The floor() function works on floating-point numbers and returns a floating-factor result. If the favored outcome is an integer fee, additional type conversions or rounding operations can be necessary to attain the favored integer result.

Potential Floating-Point Precision Issues: When using the floor() function with very large or tiny floating-factor numbers, precision problems associated with the confined precision of floating-point representation can get up. It can result in sudden or inaccurate effects in extreme instances. Care needs to be taken while handling such eventualities.

Limited Control over Rounding Behaviour: The floor() feature continually rounds down, which may only be appropriate for some situations. In a few cases, you could require unusual rounding behaviors, rounding to the nearest integer or rounding up. The lack of flexibility in the rounding conduct is a problem of the ground() function.

Limited Handling of Edge Cases: The floor() feature may additionally produce surprising consequences for sure side instances. For instance, while dealing with large or tiny floating-factor numbers, the function's behavior may not align with expectations due to floating-point precision barriers.

Integer input complexity: The floor() method is primarily made to work with floating-point numbers. Using the floor() function to round down integer numbers may result in pointless type conversions and possible performance loss. In certain circumstances, using the integer value directly rather than involving floating-point calculations is more efficient.

## ceil() function in C++ :

The ceil function in C++ is used to calculate the ceiling of a given cost. The various ceiling is defined because the smallest integer is more than or equal to the given cost. In different phrases, it rounds up the value to the nearest integer.

For example, suppose you have a wide variety of 3.2. In that case, the ceiling feature will go back 4 because four is the smallest integer greater than or the same as 3.2. Similarly if you have the number -2.7, the ceiling feature will go back -2 due to the fact -2 is the smallest integer greater than or equal to -2.7.

The ceil feature is provided as part of the cmath library in C++. It can accept arguments of kind double, go with the flow, or long double and returns a fee of the identical kind.

Syntax:

The Function takes the following shape:

`double ceil(double x); float ceil(float x); long double ceil(long double x);`

The smallest integer is larger than or identical to x results from the ceil characteristic, which most effectively accepts one entry, x. The ceiling feature does not spherical x if it's far already an integer; it simply returns x.

It's important to note that the ceiling feature nearly always returns a floating-factor wide variety. If an integer result is required, it is necessary to forge the result into an integer type using static_cast or another suitable conversion technique.

Program:

`#include <iostream>#include <cmath>int main() {    double number = 3.7;    int rounded up = ceil(number);    std::cout << "Original number: " << number << std::endl;    std::cout << "Rounded up: " << rounded up << std::endl;    return 0;}`

Output:

`Original number: 3.7Rounded up: 4`

Explanation:

• We have the necessary libraries <iostream> and <cmath> to apply input/output and mathematical capabilities, respectively.
• In principle feature, we declare a variable quantity of type double and assign it the value 3.7. This variable represents the original wide variety we want to round up.
• We declare every other variable rounded-up of type int to store the rounded-up value. We use the ceil function from the <cmath> library to round up the cost of variety. The ceiling feature takes quantity as an issue and returns the smallest integer more than or equal to variety. The rounded-up value is assigned to the rounded-up variable.
• Using std::cout, we print the original wide variety and the rounded-up fee to the console. The line std::cout << "Original quantity: " << number << std::endl; prints the message "Original variety: " accompanied via the cost of quantity. Similarly, the road std::cout << "Rounded up: " << roundedUp << std::endl; prints the message "Rounded up: " accompanied through the cost of roundedUp.
• Finally, the characteristic principle ends, and we return to 0 to indicate successful software execution.

## Complexity Analysis:

### Time Complexity:

The time complexity of the ceiling feature itself depends on the implementation info and the underlying hardware architecture. However, in the well-known, its miles are considered to have a regular time complexity, denoted as O(1).

The rest of the code includes variable declarations, assignments, and console output with regular time complexity.

Therefore, the available time complexity of the code snippet is O(1), indicating that the execution time is steady and now not depending on the input size.

### Space Complexity:

The space complexity of the code snippet is likewise steady, denoted as O(1). It uses some variables (quantity and rounded up) most effectively, occupying a set quantity of reminiscence regardless of the entry length.

The additional reminiscence used by the <iostream> and <cmath> libraries is negligible for space complexity evaluation. Hence, the space complexity of the code snippet is O(1), indicating that it uses a steady quantity of reminiscence.

## Applications of ceil() in C++ :

The ceil() feature in C++ has diverse applications in different domains. Here are some standard applications:

Rounding Up: The purpose of the ceil() function is to spherical up a given  value to the closest integer. It is typically used to ensure that a value is rounded as much as the following whole number, regardless of its fractional element. It can be useful in financial calculations, statistical evaluation, and any state of affairs where values must be rounded up for accurate outcomes.

Pagination: When managing package pagination, the ceil() feature can determine the total number of pages required. For example, when you have a complete range of objects and need to show an upbeat variety of objects in line with the web page, you could use ceil() to calculate the range of pages needed, thinking about any remaining gadgets requiring an additional page.

User Interface Layout: In graphical user interface (GUI) improvement, the ceil() function may be used to determine the number of rows or columns had to show a hard and fast of elements. For instance, when you have a grid-based layout and need to calculate the number of rows or columns primarily based on the to-be-had area and the size of every detail, ceil() may be used to ensure that you have sufficient rows or columns to deal with all of the factors.

Time Conversions: The ceil() feature can be helpful while converting time gadgets. For instance, when you have a time length in seconds and want to convert it to minutes, you may use ceil() function to spherical up the result to the nearest complete minute. It ensures that your account is for any partial mins within the conversion.

Resource Allocation: In resource allocation problems, the ceil() function can assist in determining the minimum required resources. For example, if you have a positive number of responsibilities that want to be finished using a fixed number of employees, ceil() may be used to calculate the minimum wide variety of workers wished, considering any final tasks requiring a further employee.

Data Analysis: Data evaluation frequently involves grouping or categorizing facts into discrete gadgets. Ceil() may be used to determine the variety of packing containers or intervals had to constitute the information appropriately. It ensures that the records are split frivolously and prevents any loss of information because of rounding down.

User Interface: When designing consumer interfaces, allocating entire gadgets or discrete quantities of aid can be essential. Ceil() may be used to spherical up person inputs or calculations to decide the minimal wide variety of gadgets needed or to ensure enough resources are allotted.

Financial Calculations: In economic calculations, rounding up to the nearest whole quantity is often required. For example, while calculating hobby or loan bills, ceil() can be used to ensure that fractional values are rounded up to the nearest cent or greenback.

## Advantages of ceil() in C++:

There are various advantages of the ceil() function in C++. Some main advantages of the ceil() function in C++ are as follows:

Rounding Up: One of the primary advantages of the ceil() feature is its capacity to round up a given fee to the closest integer. It may be beneficial when you must ensure that a cost is continually rounded up, regardless of its fractional part. For instance, you could spherical up charges or interest rates to the following variables in monetary calculations.

Accuracy: ceil() provides accurate rounding by thinking about the fractional part of a range. It effectively handles positive and poor values, ensuring that the result is the smallest integer greater than or equal to the entry fee. This accuracy is crucial in various programs, such as statistical evaluation or dealing with particular calculations requiring proper rounding.

Convenient and Easy to Use: The ceil() function is with no trouble available inside the <cmath> library, that's part of the C++ Standard Library. This way that it's miles covered inside the trendy set of capabilities provided through the language, making it smooth to comprise into your code. You can encompass the perfect header and use ceil() without additional setup or external dependencies.

Clear and Readable Code: Using the ceil() feature, you may write clean and readable code, conveying your motive to spherical up a fee. It can enhance the maintainability of your codebase and make it easier for other developers to understand and work together with your code.

Mathematical Consistency: The ceil() function aligns with the mathematical concept of the ceiling, which rounds up a fee to the closest integer. This consistency with mathematical concepts permits simpler communique and understanding while discussing rounding operations or mathematical calculations regarding ceil.

Standardized Naming: The ceil() function follows a standardized naming convention. It is broadly identified and understood by C++ developers. It makes it easier to search for documentation, search for help from online resources, and collaborate with different developers who are familiar with the same old library and its functions.

Compatibility: Compilers and exceptional structures widely support the ceil() capability. It may be found in the <cmath> header and is a component of the C++ Standard Library. Because of its standardized nature, your code can be easily adapted to and implemented in various unique situations without needing modification.

Standard Function: ceil() is a famous mathematical function in the C++ Standard Library. It is widely supported through compilers and readily available via the <cmath> header. Its standardized nature ensures that your code may be compatible and portable across different platforms and environments without custom implementations.

Compatible with Positive and Negative Numbers: ceil() function works effectively with beautiful and negative numbers. It correctly handles values on each zero aspect, ensuring that tremendous numbers are rounded as much as the next integer and terrible numbers are rounded toward zero.

## Disadvantages of ceil() in C++:

There are various disadvantages of the ceil() function in C++. Some main disadvantages of the ceil() function in C++ are as follows:

Limited Rounding Direction: The most crucial downside of ceil() is that it always rounds up a cost to the nearest integer, regardless of the fee's fractional element. In this case, you need distinct rounding behaviors, along with rounding down or rounding to the closest even variety. You'll want to apply other rounding capabilities or implement custom logic. Ceil() specializes in rounding up and would not provide options for different rounding instructions.

Limited Precision: The ceil() feature operates on floating-point numbers with confined precision. Floating-point numbers have a finite range of bits allocated for storing the fractional element, which can result in precision troubles, specifically when working with very big or small numbers or complicated calculations. It's crucial to be privy to capability precision troubles while using ceil() and to remember alternative strategies if excessive precision is required.

Dependency on Floating-Point Arithmetic: ceil() is designed for floating-factor mathematics and works with large floating-point numbers. If you work entirely with integers, using ceil() may contain useless kind conversions and introduce a few overheads. Applying integer-precise rounding functions or strategies is probably more efficient in such cases.

Performance Considerations: While ceil() usually has a constant time complexity, overall performance can also range depending on the implementation and the hardware architecture. Where performance is essential, it is well worth evaluating the effect of the use of ceil() on the general application execution time. In some cases, opportunity tactics or optimizations also provide higher performance, particularly when managing massive datasets or time-touchy operations.

Potential Precision Issues with Very Large or Very Small Numbers: When running with extremely large or tiny numbers, the precision of floating-point arithmetic can emerge as a subject. In rounding operations, using ceil() on such numbers may result in sudden effects or lack of precision. Awareness of these capability precision troubles is crucial, as remembering opportunity techniques or information types if required.

Lack of Control Over Rounding Modes: The ceil() function uses a specific rounding mode, rounding as much as the nearest integer. However, in some cases, you can want extra management over the rounding mode, including rounding to the nearest even range or rounding closer to zero. In such conditions, you may need to apply other rounding features or enforce a good custom judgment to achieve the preferred rounding conduct.

## Conclusion on floor() and ceil():

When deciding between floor() and ceiling (), remember the specific rounding behavior you require on your software. If you want to spherical down or truncate values, use floor(). Use ceil() function, if you need to spherical up or acquire the next whole variety. Both capabilities are without problems to be had in the <cmath> library and are broadly supported.

However, it's essential to be aware of ability precision problems when operating with big or small numbers. Additionally, consider the overall performance implications, especially while managing various values or in performance-important scenarios.

If you require more manipulation over the rounding mode or specific rounding behaviors, you can want to discover different rounding functions or implement custom common sense. Ultimately, the choice between floor() and ceil() relies upon your unique requirements, precision desires, and performance considerations.