# std::signbit

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

This function detects the sign bit of zeroes, infinities, and NaNs. Along with std::copysign, std::signbit is one of the only two portable ways to examine the sign of a NaN.

## Official Specification Summary (cppreference)

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

bool signbit( float num );
bool signbit( double num );
bool signbit( long double num ); // (1) (since C++11) (until C++23)

constexpr bool signbit( /*floating-point-type*/ num ); // (1) (since C++23)

// SIMD overload (since C++26)

// Defined in header <simd>

template< /*math-floating-point*/ V >
constexpr typename /*deduced-simd-t*/<V>::mask_type
  signbit ( const V& v_num ); // (S) (since C++26)

// Additional overloads

// Defined in header <cmath>

template< class Integer >
bool signbit( Integer num ); // (A) (since C++11) (constexpr since C++23)
```

1) Determines if the given floating point number `num` is negative. The library provides overloads for all cv-unqualified floating-point types as the type of the parameter `num`. (since C++23)

(since C++26):

S) The SIMD overload performs an element-wise `std::signbit` on `v_num`.

  (See `math-floating-point` and `deduced-simd-t` for their definitions.)

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

### Parameters

- `num` - floating-point or integer value
- `v_num` - a data-parallel object of `std::basic_simd` specialization where its element type is a floating-point type

### Return value

1) `true` if `num` is negative, `false` otherwise.

S) A data-parallel mask object where the ith element equals `true` if `v_num[i]` is negative or `false` otherwise for all `i` in the range `[​0​,` `v_num.size())`.

### Notes

This function detects the sign bit of zeroes, infinities, and NaNs. Along with `std::copysign`, `std::signbit` is one of the only two portable ways to examine the sign of a NaN.

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

### Example

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

int main()
{
    std::cout << std::boolalpha
              << "signbit(+0.0) = " << std::signbit(+0.0) << '\n'
              << "signbit(-0.0) = " << std::signbit(-0.0) << '\n'
              << "signbit(+nan) = " << std::signbit(+NAN) << '\n'
              << "signbit(-nan) = " << std::signbit(-NAN) << '\n'
              << "signbit(+inf) = " << std::signbit(+INFINITY) << '\n'
              << "signbit(-inf) = " << std::signbit(-INFINITY) << '\n';
}
```

Output:

```text
signbit(+0.0) = false
signbit(-0.0) = true
signbit(+nan) = false
signbit(-nan) = true
signbit(+inf) = false
signbit(-inf) = true
```

### See also

- [`abs(float)`](https://en.cppreference.com/w/cpp/numeric/math/fabs), [`fabs`](https://en.cppreference.com/w/cpp/numeric/math/fabs), [`fabsf`](https://en.cppreference.com/w/cpp/numeric/math/fabs) (C++11), [`fabsl`](https://en.cppreference.com/w/cpp/numeric/math/fabs) (C++11): absolute value of a floating point value (|x|) (function)
- [`copysign`](https://en.cppreference.com/w/cpp/numeric/math/copysign) (C++11), [`copysignf`](https://en.cppreference.com/w/cpp/numeric/math/copysign) (C++11), [`copysignl`](https://en.cppreference.com/w/cpp/numeric/math/copysign) (C++11): copies the sign of a floating point value (function)
- [C documentation for `signbit`](https://en.cppreference.com/w/c/numeric/math/signbit)

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