# FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO, FE_UPWARD

> C++ Atlas: `cppatlas.com/w/cpp/numeric/fenv/FE_round` | Source: https://en.cppreference.com/w/cpp/numeric/fenv/FE_round | Domain: Numerics | Standards: C++11

Each of these macro constants expands to a nonnegative integer constant expression, which can be used with std::fesetround and std::fegetround to indicate one of the supported floating-point rounding modes.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <cfenv>
#define FE_DOWNWARD     /*implementation defined*/ // (since C++11)
#define FE_TONEAREST    /*implementation defined*/ // (since C++11)
#define FE_TOWARDZERO   /*implementation defined*/ // (since C++11)
#define FE_UPWARD       /*implementation defined*/ // (since C++11)
```

Each of these macro constants expands to a nonnegative integer constant expression, which can be used with `std::fesetround` and `std::fegetround` to indicate one of the supported floating-point rounding modes. The implementation may define additional rounding mode constants in `<cfenv>`, which should all begin with `FE_` followed by at least one uppercase letter. Each macro is only defined if it is supported.

**Constant — Explanation**

- `FE_DOWNWARD`: rounding towards negative infinity
- `FE_TONEAREST`: rounding towards nearest representable value
- `FE_TOWARDZERO`: rounding towards zero
- `FE_UPWARD`: rounding towards positive infinity

Additional rounding modes may be supported by an implementation.

The current rounding mode affects the following:

- results of floating-point arithmetic operators outside of constant expressions

```cpp
double x = 1;
x / 10; // 0.09999999999999999167332731531132594682276248931884765625
     // or 0.1000000000000000055511151231257827021181583404541015625
```

- results of standard library mathematical functions

```cpp
std::sqrt(2); // 1.41421356237309492343001693370752036571502685546875
           // or 1.4142135623730951454746218587388284504413604736328125
```

- floating-point to floating-point implicit conversion and casts

```cpp
double d = 1 + std::numeric_limits<double>::epsilon();
float f = d; // 1.00000000000000000000000
          // or 1.00000011920928955078125
```

- string conversions such as `std::strtod` or `std::printf`

```cpp
std::stof("0.1"); // 0.0999999940395355224609375
               // or 0.100000001490116119384765625
```

- the library rounding functions `std::nearbyint`, `std::rint`, `std::lrint`

```cpp
std::lrint(2.1); // 2 or 3
```

The current rounding mode does NOT affect the following:

- floating-point to integer implicit conversion and casts (always towards zero),
- results of floating-point arithmetic operators in expressions executed at compile time (always to nearest),
- the library functions `std::round`, `std::lround`, `std::llround`, `std::ceil`, `std::floor`, `std::trunc`.

As with any floating-point environment functionality, rounding is only guaranteed if `#pragma STDC FENV_ACCESS ON` is set.

Compilers that do not support the pragma may offer their own ways to support current rounding mode. For example Clang and GCC have the option `-frounding-math` intended to disable optimizations that would change the meaning of rounding-sensitive code.

### Example

```cpp
#include <cfenv>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
// #pragma STDC FENV_ACCESS ON

int main()
{
    std::fesetround(FE_DOWNWARD);
    std::cout << "rounding down: \n" << std::setprecision(50)
              << "         pi = " << std::acos(-1.f) << '\n'
              << "stof(\"1.1\") = " << std::stof("1.1") << '\n'
              << "  rint(2.1) = " << std::rint(2.1) << "\n\n";
    std::fesetround(FE_UPWARD);
    std::cout << "rounding up: \n"
              << "         pi = " << std::acos(-1.f) << '\n'
              << "stof(\"1.1\") = " << std::stof("1.1") << '\n'
              << "  rint(2.1) = " << std::rint(2.1) << '\n';
}
```

Output:

```text
rounding down:
         pi = 3.141592502593994140625
stof("1.1") = 1.099999904632568359375
  rint(2.1) = 2

rounding up:
         pi = 3.1415927410125732421875
stof("1.1") = 1.10000002384185791015625
  rint(2.1) = 3
```

### See also

- [`float_round_style`](https://en.cppreference.com/w/cpp/types/numeric_limits/float_round_style): indicates floating-point rounding modes (enum)
- [`fegetround`](https://en.cppreference.com/w/cpp/numeric/fenv/feround) (C++11), [`fesetround`](https://en.cppreference.com/w/cpp/numeric/fenv/feround) (C++11): gets or sets rounding direction (function)
- [C documentation for floating-point rounding macros](https://en.cppreference.com/w/c/numeric/fenv/FE_round)

---
Attribution: content from https://en.cppreference.com/w/cpp/numeric/fenv/FE_round (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.