std::bit_floor

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

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)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

Numerics library

Common mathematical functions

Mathematical special functions (C++17)

Mathematical constants (C++20)

Floating-point environment (C++11)

Complex numbers

Numeric arrays

Pseudo-random number generation

Compile-time rational arithmetic (C++11)

Numeric algorithms

gcd (C++17)

lcm (C++17)

Interpolations

midpoint (C++20)

lerp (C++20)

Generic numeric operations

iota (C++11)

accumulate

inner_product

adjacent_difference

partial_sum

reduce (C++17)

transform_reduce (C++17)

inclusive_scan (C++17)

exclusive_scan (C++17)

transform_inclusive_scan (C++17)

transform_exclusive_scan (C++17)

Bit operations

bit_cast (C++20)

has_single_bit (C++20)

bit_ceil (C++20)

bit_floor (C++20)

bit_width (C++20)

rotl (C++20)

rotr (C++20)

countl_zero (C++20)

countl_one (C++20)

countr_zero (C++20)

countr_one (C++20)

popcount (C++20)

endian (C++20)

 

Defined in header <bit>
template< class T > constexpr T bit_floor(T x) noexcept;		(since C++20)

If x is not zero, calculates the largest integral power of two that is not greater than x. If x is zero, returns zero.

This overload only participates in overload resolution if T is an unsigned integer type (that is, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long, or an extended unsigned integer type).

Return value

Zero if x is zero; otherwise, the largest integral power of two that is not greater than x.

Possible implementation

template <std::unsigned_integral T> requires !std::same_as<T, bool> && !std::same_as<T, char> && !std::same_as<T, char8_t> && !std::same_as<T, char16_t> && !std::same_as<T, char32_t> && !std::same_as<T, wchar_t> constexpr T bit_floor(T x) noexcept { if (x != 0) return T{1} << (std::bit_width(x) - 1); return 0; }

Example

Run this code

#include <bit>
#include <bitset>
#include <iostream>
 
auto main() -> int
{
    using bin = std::bitset<8>;
 
    for (unsigned x = 0; x != 10; ++x)
    {
        auto const z = std::bit_floor(x); // `floor2` before P1956R1
 
        std::cout << "bit_floor(" << bin(x) << ") = " << bin(z) << '\n';
    }
}

Output:

bit_floor(00000000) = 00000000
bit_floor(00000001) = 00000001
bit_floor(00000010) = 00000010
bit_floor(00000011) = 00000010
bit_floor(00000100) = 00000100
bit_floor(00000101) = 00000100
bit_floor(00000110) = 00000100
bit_floor(00000111) = 00000100
bit_floor(00001000) = 00001000
bit_floor(00001001) = 00001000

See also

bit_ceil (C++20)	finds the smallest integral power of two not less than the given value (function template)
rotr (C++20)	computes the result of bitwise right-rotation (function template)
bit_width (C++20)	finds the smallest number of bits needed to represent the given value (function template)
has_single_bit (C++20)	checks if a number is an integral power of two (function template)