home | help 
std::bit_floor(3)	       C++ Standard Libary	       std::bit_floor(3)

NAME
     std::bit_floor - std::bit_floor

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

	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 participates in overload resolution only if T  is  an  un-
     signed integer
	type  (that  is,  unsigned  char, unsigned short, unsigned int, unsigned
     long, unsigned
	long long, or an extended unsigned integer type).

Parameters
	x - unsigned integer value

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

Notes
	Feature-test macro  Value    Std	      Feature
	__cpp_lib_int_pow2 202002L (C++20) Integral power-of-2 operations

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>

      int main()
      {
	  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	finds  the  smallest integral power of two not less than
     the given
	(C++20)        value
		       (function template)
	rotr	       computes the result of bitwise right-rotation
	(C++20)        (function template)
	bit_width      finds the smallest number of bits needed to represent the
     given value
	(C++20)        (function template)
	has_single_bit checks if a number is an integral power of 2
	(C++20)        (function template)

http://cppreference.com 	   2024.06.10		       std::bit_floor(3)
home | help