# std::frexp, std::frexpf, std::frexpl

> C++ Atlas: `cppatlas.com/w/cpp/numeric/math/frexp` | Source: https://en.cppreference.com/w/cpp/numeric/math/frexp | Domain: Numerics | Standards: C++11, C++23

If num is zero, returns zero and stores zero in *exp.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <cmath>

float       frexp ( float num, int* exp );
double      frexp ( double num, int* exp );
long double frexp ( long double num, int* exp ); // (1) (until C++23)

constexpr /* floating-point-type */
            frexp ( /* floating-point-type */ num, int* exp ); // (1) (since C++23)

float       frexpf( float num, int* exp ); // (2) (since C++11) (constexpr since C++23)

long double frexpl( long double num, int* exp ); // (3) (since C++11) (constexpr since C++23)

// Additional overloads (since C++11)

// Defined in header <cmath>

template< class Integer >
double      frexp ( Integer num, int* exp ); // (A) (constexpr since C++23)
```

1-3) Decomposes given floating point value `num` into a normalized fraction and an integral exponent of two. The library provides overloads of `std::frexp` for all cv-unqualified floating-point types as the type of the parameter `num`. (since C++23)

A) Additional overloads are provided for all integer types, which are treated as `double`. (since C++11)

### Parameters

- `num` - floating-point or integer value
- `exp` - pointer to integer value to store the exponent to

### Return value

If `num` is zero, returns zero and stores zero in `*exp`.

Otherwise (if `num` is not zero), if no errors occur, returns the value `x` in the range `(-1, -0.5], [0.5, 1)` and stores an integer value in `*exp` such that x×2^((*exp))== num.

If the value to be stored in `*exp` is outside the range of `int`, the behavior is unspecified.

### Error handling

This function is not subject to any errors specified in `math_errhandling`.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

- If `num` is ±0, it is returned, unmodified, and `​0​` is stored in `*exp`.
- If `num` is ±∞, it is returned, and an unspecified value is stored in `*exp`.
- If `num` is NaN, NaN is returned, and an unspecified value is stored in `*exp`.
- No floating-point exceptions are raised.
- If `FLT_RADIX` is 2 (or a power of 2), the returned value is exact, the current rounding mode is ignored.

### Notes

On a binary system (where `FLT_RADIX` is `2`), `std::frexp` may be implemented as

```cpp
{
    *exp = (value == 0) ? 0 : (int)(1 + std::logb(value));
    return std::scalbn(value, -(*exp));
}
```

The function `std::frexp`, together with its dual, `std::ldexp`, can be used to manipulate the representation of a floating-point number without direct bit manipulations.

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::frexp(num, exp)` has the same effect as `std::frexp(static_cast<double>(num), exp)`.

### Example

Compares different floating-point decomposition functions:

```cpp
#include <cmath>
#include <iostream>
#include <limits>

int main()
{
    double f = 123.45;
    std::cout << "Given the number " << f << " or " << std::hexfloat
              << f << std::defaultfloat << " in hex,\n";

    double f3;
    double f2 = std::modf(f, &f3);
    std::cout << "modf() makes " << f3 << " + " << f2 << '\n';

    int i;
    f2 = std::frexp(f, &i);
    std::cout << "frexp() makes " << f2 << " * 2^" << i << '\n';

    i = std::ilogb(f);
    std::cout << "logb()/ilogb() make " << f / std::scalbn(1.0, i)
              << " * " << std::numeric_limits<double>::radix
              << "^" << std::ilogb(f) << '\n';
}
```

Possible output:

```text
Given the number 123.45 or 0x1.edccccccccccdp+6 in hex,
modf() makes 123 + 0.45
frexp() makes 0.964453 * 2^7
logb()/ilogb() make 1.92891 * 2^6
```

### See also

- [`ldexp`](https://en.cppreference.com/w/cpp/numeric/math/ldexp), [`ldexpf`](https://en.cppreference.com/w/cpp/numeric/math/ldexp) (C++11), [`ldexpl`](https://en.cppreference.com/w/cpp/numeric/math/ldexp) (C++11): multiplies a number by 2 raised to an integral power (function)
- [`logb`](https://en.cppreference.com/w/cpp/numeric/math/logb) (C++11), [`logbf`](https://en.cppreference.com/w/cpp/numeric/math/logb) (C++11), [`logbl`](https://en.cppreference.com/w/cpp/numeric/math/logb) (C++11): extracts exponent of the number (function)
- [`ilogb`](https://en.cppreference.com/w/cpp/numeric/math/ilogb) (C++11), [`ilogbf`](https://en.cppreference.com/w/cpp/numeric/math/ilogb) (C++11), [`ilogbl`](https://en.cppreference.com/w/cpp/numeric/math/ilogb) (C++11): extracts exponent of the number (function)
- [`modf`](https://en.cppreference.com/w/cpp/numeric/math/modf), [`modff`](https://en.cppreference.com/w/cpp/numeric/math/modf) (C++11), [`modfl`](https://en.cppreference.com/w/cpp/numeric/math/modf) (C++11): decomposes a number into integer and fractional parts (function)
- [C documentation for `frexp`](https://en.cppreference.com/w/c/numeric/math/frexp)

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