31#ifndef ETL_BINARY_INCLUDED
32#define ETL_BINARY_INCLUDED
42#include "static_assert.h"
49#if ETL_USING_CPP20 && ETL_USING_STL
88 template <
size_t NBITS>
91 typedef typename etl::smallest_uint_for_bits<NBITS>::type value_type;
92 static ETL_CONSTANT value_type value = (value_type(1) << (NBITS - 1)) |
max_value_for_nbits<NBITS - 1>::value;
99 typedef etl::smallest_uint_for_bits<0>::type value_type;
100 static ETL_CONSTANT value_type value = 0;
103 template <
size_t NBITS>
107 template <
size_t NBITS>
115 template <
typename T>
118#if ETL_USING_CPP20 && ETL_USING_STL
119 return std::rotl(value, 1);
125 return (value << 1U) | (value >>
SHIFT);
133 template <
typename T>
136#if ETL_USING_CPP20 && ETL_USING_STL
137 return std::rotl(value, distance);
151 return (value << distance) | (value >>
SHIFT);
160 template <
typename T>
163#if ETL_USING_CPP20 && ETL_USING_STL
164 return std::rotr(value, 1);
170 return (value >> 1U) | (value <<
SHIFT);
178 template <
typename T>
181#if ETL_USING_CPP20 && ETL_USING_STL
182 return std::rotr(value, distance);
196 return (value >> distance) | (value <<
SHIFT);
206 template <
typename T>
229 template <
typename T>
234 return (value >> 1U) ^ value;
241 template <
typename TReturn,
size_t NBITS,
typename TValue>
247 ETL_CONSTANT
size_t shift = NBITS;
270 template <
typename TReturn,
size_t NBITS,
typename TValue>
279 signed value : NBITS;
282 return (
s.value = value);
291 template <
typename TReturn,
size_t NBITS,
size_t SHIFT,
typename TValue>
301 signed value : NBITS;
304 return (
s.value = (value >>
SHIFT));
312 template <
typename TReturn,
typename TValue>
332 template <
typename TReturn,
typename TValue>
351 template <
size_t POSITION>
354 typedef typename etl::smallest_uint_for_bits<POSITION + 1U>::type value_type;
355 static ETL_CONSTANT value_type value = value_type(1) <<
POSITION;
358 template <
size_t POSITION>
362 template <
size_t POSITION>
363 using bit_t =
typename etl::bit<POSITION>::value_type;
367 template <
size_t POSITION>
375 template <
typename TResult,
typename TValue>
378 ETL_STATIC_ASSERT(
sizeof(
TResult) >=
sizeof(
TValue),
"Result must be at least as large as the fill value");
390 template <
typename TResult,
typename TValue, TValue N>
393 ETL_STATIC_ASSERT(
sizeof(
TResult) >=
sizeof(
TValue),
"Result must be at least as large as the fill value");
401#if ETL_USING_8BIT_TYPES
406 template <
typename TValue>
407 ETL_CONSTEXPR14
bool has_zero_byte(TValue value)
411 const unsigned_t temp = unsigned_t(~((((unsigned_t(value) & mask) + mask) | unsigned_t(value)) | mask));
420 template <
typename TValue, TValue N>
421 ETL_CONSTEXPR14
bool has_zero_byte()
425 const unsigned_t temp = unsigned_t(~((((unsigned_t(N) & mask) + mask) | unsigned_t(N)) | mask));
434 template <
typename TValue>
435 ETL_CONSTEXPR14
bool has_byte_n(TValue value, uint8_t n)
444 template <
typename TValue, TValue N>
445 ETL_CONSTEXPR14
bool has_byte_n(TValue value)
457 template <
typename T>
460 return second ^ ((second ^ first) &
mask);
469 template <
typename T, T MASK>
472 return second ^ ((second ^ first) &
MASK);
479 template <
typename T, T Value>
482#if ETL_USING_8BIT_TYPES
487 template <
typename T>
492 value = ((value & 0xAAU) >> 1U) | ((value & 0x55U) << 1U);
493 value = ((value & 0xCCU) >> 2U) | ((value & 0x33U) << 2U);
494 value = (value >> 4U) | ((value & 0x0FU) << 4U);
500 template <u
int8_t Value>
506 static ETL_CONSTANT
uint8_t value2 =
uint8_t(((value1 & 0xCCU) >> 2U) | ((value1 & 0x33U) << 2U));
510 static ETL_CONSTANT
uint8_t value =
uint8_t((value2 >> 4U) | ((value2 & 0x0FU) << 4U));
513 template <u
int8_t Value>
514 ETL_CONSTANT uint8_t reverse_bits_const<uint8_t, Value>::value;
517 template <
int8_t Value>
518 struct reverse_bits_const<int8_t, Value>
522 static ETL_CONSTANT int8_t value1 = int8_t(((Value & 0xAAU) >> 1U) | ((Value & 0x55U) << 1U));
523 static ETL_CONSTANT int8_t value2 = int8_t(((value1 & 0xCCU) >> 2U) | ((value1 & 0x33U) << 2U));
527 static ETL_CONSTANT int8_t value = int8_t((value2 >> 4U) | ((value2 & 0x0FU) << 4U));
530 template <
int8_t Value>
531 ETL_CONSTANT int8_t reverse_bits_const<int8_t, Value>::value;
538 template <
typename T>
543 value = ((value & 0xAAAAU) >> 1U) | ((value & 0x5555U) << 1U);
544 value = ((value & 0xCCCCU) >> 2U) | ((value & 0x3333U) << 2U);
545 value = ((value & 0xF0F0U) >> 4U) | ((value & 0x0F0FU) << 4U);
546 value = (value >> 8U) | ((value & 0xFFU) << 8U);
552 template <u
int16_t Value>
558 static ETL_CONSTANT
uint16_t value2 =
uint16_t(((value1 & 0xCCCCU) >> 2U) | ((value1 & 0x3333U) << 2U));
559 static ETL_CONSTANT
uint16_t value3 =
uint16_t(((value2 & 0xF0F0U) >> 4U) | ((value2 & 0x0F0FU) << 4U));
563 static ETL_CONSTANT
uint16_t value =
uint16_t((value3 >> 8U) | ((value3 & 0xFFU) << 8U));
566 template <u
int16_t Value>
570 template <
int16_t Value>
576 static ETL_CONSTANT
int16_t value2 =
int16_t(((value1 & 0xCCCCU) >> 2U) | ((value1 & 0x3333U) << 2U));
577 static ETL_CONSTANT
int16_t value3 =
int16_t(((value2 & 0xF0F0U) >> 4U) | ((value2 & 0x0F0FU) << 4U));
581 static ETL_CONSTANT
int16_t value =
int16_t((value3 >> 8U) | ((value3 & 0xFFU) << 8U));
584 template <
int16_t Value>
591 template <
typename T>
596 value = ((value & 0xAAAAAAAAUL) >> 1U) | ((value & 0x55555555UL) << 1U);
597 value = ((value & 0xCCCCCCCCUL) >> 2U) | ((value & 0x33333333UL) << 2U);
598 value = ((value & 0xF0F0F0F0UL) >> 4U) | ((value & 0x0F0F0F0FUL) << 4U);
599 value = ((value & 0xFF00FF00UL) >> 8U) | ((value & 0x00FF00FFUL) << 8U);
600 value = (value >> 16U) | ((value & 0xFFFFU) << 16U);
606 template <u
int32_t Value>
612 static ETL_CONSTANT
uint32_t value2 =
uint32_t(((value1 & 0xCCCCCCCCUL) >> 2U) | ((value1 & 0x33333333UL) << 2U));
613 static ETL_CONSTANT
uint32_t value3 =
uint32_t(((value2 & 0xF0F0F0F0UL) >> 4U) | ((value2 & 0x0F0F0F0FUL) << 4U));
614 static ETL_CONSTANT
uint32_t value4 =
uint32_t(((value3 & 0xFF00FF00UL) >> 8U) | ((value3 & 0x00FF00FFUL) << 8U));
618 static ETL_CONSTANT
uint32_t value =
uint32_t((value4 >> 16U) | ((value4 & 0xFFFFU) << 16U));
621 template <u
int32_t Value>
625 template <
int32_t Value>
631 static ETL_CONSTANT
int32_t value2 =
int32_t(((value1 & 0xCCCCCCCCUL) >> 2U) | ((value1 & 0x33333333UL) << 2U));
632 static ETL_CONSTANT
int32_t value3 =
int32_t(((value2 & 0xF0F0F0F0UL) >> 4U) | ((value2 & 0x0F0F0F0FUL) << 4U));
633 static ETL_CONSTANT
int32_t value4 =
int32_t(((value3 & 0xFF00FF00UL) >> 8U) | ((value3 & 0x00FF00FFUL) << 8U));
637 static ETL_CONSTANT
int32_t value =
int32_t((value4 >> 16U) | ((value4 & 0xFFFFUL) << 16U));
640 template <
int32_t Value>
643#if ETL_USING_64BIT_TYPES
648 template <
typename T>
653 value = ((value & 0xAAAAAAAAAAAAAAAAULL) >> 1U) | ((value & 0x5555555555555555ULL) << 1U);
654 value = ((value & 0xCCCCCCCCCCCCCCCCULL) >> 2U) | ((value & 0x3333333333333333ULL) << 2U);
655 value = ((value & 0xF0F0F0F0F0F0F0F0ULL) >> 4U) | ((value & 0x0F0F0F0F0F0F0F0FULL) << 4U);
656 value = ((value & 0xFF00FF00FF00FF00ULL) >> 8U) | ((value & 0x00FF00FF00FF00FFULL) << 8U);
657 value = ((value & 0xFFFF0000FFFF0000ULL) >> 16U) | ((value & 0x0000FFFF0000FFFFULL) << 16U);
658 value = (value >> 32U) | ((value & 0xFFFFFFFFULL) << 32U);
664 template <u
int64_t Value>
669 static ETL_CONSTANT
uint64_t value1 =
uint64_t(((
Value & 0xAAAAAAAAAAAAAAAAULL) >> 1U) | ((
Value & 0x5555555555555555ULL) << 1U));
670 static ETL_CONSTANT
uint64_t value2 =
uint64_t(((value1 & 0xCCCCCCCCCCCCCCCCULL) >> 2U) | ((value1 & 0x3333333333333333ULL) << 2U));
671 static ETL_CONSTANT
uint64_t value3 =
uint64_t(((value2 & 0xF0F0F0F0F0F0F0F0ULL) >> 4U) | ((value2 & 0x0F0F0F0F0F0F0F0FULL) << 4U));
672 static ETL_CONSTANT
uint64_t value4 =
uint64_t(((value3 & 0xFF00FF00FF00FF00ULL) >> 8U) | ((value3 & 0x00FF00FF00FF00FFULL) << 8U));
673 static ETL_CONSTANT
uint64_t value5 =
uint64_t(((value4 & 0xFFFF0000FFFF0000ULL) >> 16U) | ((value4 & 0x0000FFFF0000FFFFULL) << 16U));
677 static ETL_CONSTANT
uint64_t value =
uint64_t((value5 >> 32U) | ((value5 & 0xFFFFFFFFULL) << 32U));
680 template <u
int64_t Value>
684 template <
int64_t Value>
689 static ETL_CONSTANT
int64_t value1 =
int64_t(((
Value & 0xAAAAAAAAAAAAAAAAULL) >> 1U) | ((
Value & 0x5555555555555555ULL) << 1U));
690 static ETL_CONSTANT
int64_t value2 =
int64_t(((value1 & 0xCCCCCCCCCCCCCCCCULL) >> 2U) | ((value1 & 0x3333333333333333ULL) << 2U));
691 static ETL_CONSTANT
int64_t value3 =
int64_t(((value2 & 0xF0F0F0F0F0F0F0F0ULL) >> 4U) | ((value2 & 0x0F0F0F0F0F0F0F0FULL) << 4U));
692 static ETL_CONSTANT
int64_t value4 =
int64_t(((value3 & 0xFF00FF00FF00FF00ULL) >> 8U) | ((value3 & 0x00FF00FF00FF00FFULL) << 8U));
693 static ETL_CONSTANT
int64_t value5 =
int64_t(((value4 & 0xFFFF0000FFFF0000ULL) >> 16U) | ((value4 & 0x0000FFFF0000FFFFULL) << 16U));
697 static ETL_CONSTANT
int64_t value =
int64_t((value5 >> 32U) | ((value5 & 0xFFFFFFFFULL) << 32U));
700 template <
int64_t Value>
708 template <
typename T>
722#if ETL_USING_8BIT_TYPES
723 template <
typename T>
736 template <
typename T>
741#if ETL_CPP23_SUPPORTED && ETL_USING_STL
742 return std::byteswap(value);
744 return (value >> 8U) | (value << 8U);
752 template <
typename T>
757#if ETL_CPP23_SUPPORTED && ETL_USING_STL
758 return std::byteswap(value);
760 value = ((value & 0xFF00FF00UL) >> 8U) | ((value & 0x00FF00FFUL) << 8U);
761 value = (value >> 16U) | (value << 16U);
767#if ETL_USING_64BIT_TYPES
772 template <
typename T>
777#if ETL_CPP23_SUPPORTED && ETL_USING_STL
778 return std::byteswap(value);
780 value = ((value & 0xFF00FF00FF00FF00ULL) >> 8U) | ((value & 0x00FF00FF00FF00FFULL) << 8U);
781 value = ((value & 0xFFFF0000FFFF0000ULL) >> 16U) | ((value & 0x0000FFFF0000FFFFULL) << 16U);
782 value = (value >> 32U) | (value << 32U);
793 template <
typename T>
803#if ETL_USING_8BIT_TYPES
808 template <
typename T>
813 value ^= (value >> 4U);
814 value ^= (value >> 2U);
815 value ^= (value >> 1U);
825 template <
typename T>
830 value ^= (value >> 8U);
831 value ^= (value >> 4U);
832 value ^= (value >> 2U);
833 value ^= (value >> 1U);
842 template <
typename T>
847 value ^= (value >> 16U);
848 value ^= (value >> 8U);
849 value ^= (value >> 4U);
850 value ^= (value >> 2U);
851 value ^= (value >> 1U);
856#if ETL_USING_64BIT_TYPES
861 template <
typename T>
866 value ^= (value >> 32U);
867 value ^= (value >> 16U);
868 value ^= (value >> 8U);
869 value ^= (value >> 4U);
870 value ^= (value >> 2U);
871 value ^= (value >> 1U);
881 template <
typename T>
891#if ETL_USING_8BIT_TYPES
896 template <
typename T>
901#if ETL_CPP23_SUPPORTED && ETL_USING_STL
902 return std::popcount(value);
906 count = value - ((value >> 1U) & 0x55U);
907 count = ((count >> 2U) & 0x33U) + (count & 0x33U);
908 count = ((count >> 4U) + count) & 0x0FU;
910 return uint_least8_t(count);
919 template <
typename T>
924#if ETL_USING_CPP20 && ETL_USING_STL
925 return std::popcount(value);
929 count = value - ((value >> 1U) & 0x5555U);
930 count = ((count >> 2U) & 0x3333U) + (count & 0x3333U);
931 count = ((count >> 4U) + count) & 0x0F0FU;
932 count = ((count >> 8U) + count) & 0x00FFU;
942 template <
typename T>
947#if ETL_USING_CPP20 && ETL_USING_STL
948 return std::popcount(value);
952 count = value - ((value >> 1U) & 0x55555555UL);
953 count = ((count >> 2U) & 0x33333333UL) + (count & 0x33333333UL);
954 count = ((count >> 4U) + count) & 0x0F0F0F0FUL;
955 count = ((count >> 8U) + count) & 0x00FF00FFUL;
956 count = ((count >> 16U) + count) & 0x0000FFUL;
962#if ETL_USING_64BIT_TYPES
967 template <
typename T>
972#if ETL_USING_CPP20 && ETL_USING_STL
973 return std::popcount(value);
977 count = value - ((value >> 1U) & 0x5555555555555555ULL);
978 count = ((count >> 2U) & 0x3333333333333333ULL) + (count & 0x3333333333333333ULL);
979 count = ((count >> 4U) + count) & 0x0F0F0F0F0F0F0F0FULL;
980 count = ((count >> 8U) + count) & 0x00FF00FF00FF00FFULL;
981 count = ((count >> 16U) + count) & 0x0000FFFF0000FFFFULL;
982 count = ((count >> 32U) + count) & 0x00000000FFFFFFFFULL;
993 template <
typename T>
1003#if ETL_USING_8BIT_TYPES
1008 template <
typename T>
1013 value ^= value >> 4U;
1015 return (0x6996U >> value) & 1U;
1023 template <
typename T>
1028 value ^= value >> 8U;
1029 value ^= value >> 4U;
1031 return (0x6996U >> value) & 1U;
1038 template <
typename T>
1043 value ^= value >> 16U;
1044 value ^= value >> 8U;
1045 value ^= value >> 4U;
1047 return (0x6996U >> value) & 1U;
1050#if ETL_USING_64BIT_TYPES
1055 template <
typename T>
1060 value ^= value >> 32U;
1061 value ^= value >> 16U;
1062 value ^= value >> 8U;
1063 value ^= value >> 4U;
1065 return (0x69966996UL >> value) & 1U;
1073 template <
typename T>
1083#if ETL_USING_8BIT_TYPES
1089 template <
typename T>
1094#if ETL_USING_CPP20 && ETL_USING_STL
1095 return std::countr_zero(value);
1097 uint_least8_t count = 0U;
1107 if ((value & 0xFU) == 0U)
1113 if ((value & 0x3U) == 0U)
1119 if ((value & 0x1U) == 0U)
1125 count -= (value & 0x1U);
1138 template <
typename T>
1143#if ETL_USING_CPP20 && ETL_USING_STL
1144 return std::countr_zero(value);
1156 if ((value & 0xFFU) == 0
U)
1162 if ((value & 0xFU) == 0
U)
1168 if ((value & 0x3U) == 0
U)
1174 if ((value & 0x1U) == 0
U)
1180 count -= value & 0x1U;
1192 template <
typename T>
1197#if ETL_USING_CPP20 && ETL_USING_STL
1198 return std::countr_zero(value);
1210 if ((value & 0xFFFFUL) == 0
UL)
1216 if ((value & 0xFFUL) == 0
UL)
1222 if ((value & 0xFUL) == 0
UL)
1228 if ((value & 0x3UL) == 0
UL)
1234 if ((value & 0x1U) == 0
U)
1240 count -= value & 0x1UL;
1247#if ETL_USING_64BIT_TYPES
1253 template <
typename T>
1258#if ETL_USING_CPP20 && ETL_USING_STL
1259 return std::countr_zero(value);
1271 if ((value & 0xFFFFFFFFULL) == 0
ULL)
1277 if ((value & 0xFFFFULL) == 0
ULL)
1283 if ((value & 0xFFULL) == 0
ULL)
1289 if ((value & 0xFULL) == 0
ULL)
1295 if ((value & 0x3ULL) == 0
ULL)
1301 if ((value & 0x1U) == 0
U)
1307 count -= value & 0x1ULL;
1319 template <
typename T>
1329#if ETL_USING_8BIT_TYPES
1335 template <
typename T>
1340#if ETL_USING_CPP20 && ETL_USING_STL
1341 return std::countr_one(value);
1343 uint_least8_t count = 0U;
1345 if ((value & 0x1U) == 0x0U)
1353 if ((value & 0xFU) == 0xFU)
1359 if ((value & 0x3U) == 0x3U)
1365 if ((value & 0x1U) == 0x1U)
1371 count -= ((value & 0x1U) == 0x0U);
1384 template <
typename T>
1389#if ETL_USING_CPP20 && ETL_USING_STL
1390 return std::countr_one(value);
1394 if ((value & 0x1U) == 0x0U)
1402 if ((value & 0xFFU) == 0xFFU)
1408 if ((value & 0xFU) == 0xFU)
1414 if ((value & 0x3U) == 0x3U)
1420 if ((value & 0x1U) == 0x1U)
1426 count -= ((value & 0x1U) == 0x0U);
1438 template <
typename T>
1443#if ETL_USING_CPP20 && ETL_USING_STL
1444 return std::countr_one(value);
1448 if ((value & 0x1UL) == 0x0UL)
1456 if ((value & 0xFFFFUL) == 0xFFFFUL)
1462 if ((value & 0xFFUL) == 0xFFUL)
1468 if ((value & 0xFUL) == 0xFUL)
1474 if ((value & 0x3UL) == 0x3UL)
1480 if ((value & 0x1UL) == 0x1UL)
1486 count -= ((value & 0x1UL) == 0x0UL);
1493#if ETL_USING_64BIT_TYPES
1499 template <
typename T>
1504#if ETL_USING_CPP20 && ETL_USING_STL
1505 return std::countr_one(value);
1509 if ((value & 0x1ULL) == 0x0ULL)
1517 if ((value & 0xFFFFULL) == 0xFFFFULL)
1523 if ((value & 0xFFULL) == 0xFFULL)
1529 if ((value & 0xFULL) == 0xFULL)
1535 if ((value & 0x3ULL) == 0x3ULL)
1541 if ((value & 0x1ULL) == 0x1ULL)
1547 count -= ((value & 0x1ULL) == 0x0ULL);
1559 template <
typename T>
1569#if ETL_USING_8BIT_TYPES
1575 template <
typename T>
1580#if ETL_USING_CPP20 && ETL_USING_STL
1581 return std::countl_zero(value);
1583 uint_least8_t count = 0U;
1593 if ((value & 0xF0U) == 0U)
1599 if ((value & 0xC0U) == 0U)
1605 if ((value & 0x80U) == 0U)
1611 count -= ((value & 0x80U) == 0x80U);
1624 template <
typename T>
1629#if ETL_USING_CPP20 && ETL_USING_STL
1630 return std::countl_zero(value);
1634 if (value & 0x8000U)
1642 if ((value & 0xFF00U) == 0
U)
1648 if ((value & 0xF000U) == 0
U)
1654 if ((value & 0xC000U) == 0
U)
1660 if ((value & 0x8000U) == 0
U)
1666 count -= ((value & 0x8000U) == 0x8000U);
1678 template <
typename T>
1683#if ETL_USING_CPP20 && ETL_USING_STL
1684 return std::countl_zero(value);
1688 if (value & 0x80000000UL)
1696 if ((value & 0xFFFF0000UL) == 0
U)
1702 if ((value & 0xFF000000UL) == 0
U)
1708 if ((value & 0xF0000000UL) == 0
U)
1714 if ((value & 0xC0000000UL) == 0
U)
1720 if ((value & 0x80000000UL) == 0
U)
1726 count -= ((value & 0x80000000UL) == 0x80000000UL);
1733#if ETL_USING_64BIT_TYPES
1739 template <
typename T>
1744#if ETL_USING_CPP20 && ETL_USING_STL
1745 return std::countl_zero(value);
1749 if (value & 0x8000000000000000ULL)
1757 if ((value & 0xFFFFFFFFF0000000ULL) == 0
U)
1763 if ((value & 0xFFFF000000000000ULL) == 0
U)
1769 if ((value & 0xFF00000000000000ULL) == 0
U)
1775 if ((value & 0xF000000000000000ULL) == 0
U)
1781 if ((value & 0xC000000000000000ULL) == 0
U)
1787 if ((value & 0x8000000000000000ULL) == 0
U)
1793 count -= ((value & 0x8000000000000000ULL) == 0x8000000000000000ULL);
1805 template <
typename T>
1815#if ETL_USING_8BIT_TYPES
1821 template <
typename T>
1826#if ETL_USING_CPP20 && ETL_USING_STL
1827 return std::countl_one(value);
1829 uint_least8_t count = 0U;
1831 if ((value & 0x80U) == 0U)
1839 if ((value & 0xF0U) == 0xF0U)
1845 if ((value & 0xC0U) == 0xC0U)
1851 if ((value & 0x80U) == 0x80U)
1857 count -= ((value & 0x80U) == 0x0U);
1870 template <
typename T>
1875#if ETL_USING_CPP20 && ETL_USING_STL
1876 return std::countl_one(value);
1880 if ((value & 0x8000U) == 0
U)
1888 if ((value & 0xFF00U) == 0xFF00U)
1894 if ((value & 0xF000U) == 0xF000U)
1900 if ((value & 0xC000U) == 0xC000U)
1906 if ((value & 0x8000U) == 0x8000U)
1912 count -= ((value & 0x8000U) == 0
U);
1924 template <
typename T>
1929#if ETL_USING_CPP20 && ETL_USING_STL
1930 return std::countl_one(value);
1934 if ((value & 0x80000000UL) == 0
UL)
1942 if ((value & 0xFFFF0000UL) == 0xFFFF0000UL)
1948 if ((value & 0xFF000000UL) == 0xFF000000UL)
1954 if ((value & 0xF0000000UL) == 0xF0000000UL)
1960 if ((value & 0xC0000000UL) == 0xC0000000UL)
1966 if ((value & 0x80000000UL) == 0x80000000UL)
1972 count -= ((value & 0x80000000UL) == 0
UL);
1979#if ETL_USING_64BIT_TYPES
1985 template <
typename T>
1990#if ETL_USING_CPP20 && ETL_USING_STL
1991 return std::countl_one(value);
1995 if ((value & 0x8000000000000000ULL) == 0
ULL)
2003 if ((value & 0xFFFFFFFF00000000ULL) == 0xFFFFFFFF00000000ULL)
2009 if ((value & 0xFFFF000000000000ULL) == 0xFFFF000000000000ULL)
2015 if ((value & 0xFF00000000000000ULL) == 0xFF00000000000000ULL)
2021 if ((value & 0xF000000000000000ULL) == 0xF000000000000000ULL)
2027 if ((value & 0xC000000000000000ULL) == 0xC000000000000000ULL)
2033 if ((value & 0x8000000000000000ULL) == 0x8000000000000000ULL)
2039 count -= ((value & 0x8000000000000000ULL) == 0
ULL);
2051 template <
typename T>
2066 template <
typename T>
2077 template <
typename T>
2089 template <
typename T>
2100#if ETL_USING_8BIT_TYPES
2105 template <
typename T>
2110 uint16_t f = uint16_t(first);
2111 uint16_t s = uint16_t(second);
2113 f = (f | (f << 4U)) & 0x0F0FU;
2114 f = (f | (f << 2U)) & 0x3333U;
2115 f = (f | (f << 1U)) & 0x5555U;
2117 s = (s | (s << 4U)) & 0x0F0FU;
2118 s = (s | (s << 2U)) & 0x3333U;
2119 s = (s | (s << 1U)) & 0x5555U;
2121 return (f | (s << 1U));
2129 template <
typename T>
2137 f = (
f | (
f << 8U)) & 0x00FF00FFUL;
2138 f = (
f | (
f << 4U)) & 0x0F0F0F0FUL;
2139 f = (
f | (
f << 2U)) & 0x33333333UL;
2140 f = (
f | (
f << 1U)) & 0x55555555UL;
2142 s = (
s | (
s << 8U)) & 0x00FF00FFUL;
2143 s = (
s | (
s << 4U)) & 0x0F0F0F0FUL;
2144 s = (
s | (
s << 2U)) & 0x33333333UL;
2145 s = (
s | (
s << 1U)) & 0x55555555UL;
2147 return (
f | (
s << 1U));
2150#if ETL_USING_64BIT_TYPES
2155 template <
typename T>
2163 f = (
f | (
f << 16U)) & 0x0000FFFF0000FFFFULL;
2164 f = (
f | (
f << 8U)) & 0x00FF00FF00FF00FFULL;
2165 f = (
f | (
f << 4U)) & 0x0F0F0F0F0F0F0F0FULL;
2166 f = (
f | (
f << 2U)) & 0x3333333333333333ULL;
2167 f = (
f | (
f << 1U)) & 0x5555555555555555ULL;
2169 s = (
s | (
s << 16U)) & 0x0000FFFF0000FFFFULL;
2170 s = (
s | (
s << 8U)) & 0x00FF00FF00FF00FFULL;
2171 s = (
s | (
s << 4U)) & 0x0F0F0F0F0F0F0F0FULL;
2172 s = (
s | (
s << 2U)) & 0x3333333333333333ULL;
2173 s = (
s | (
s << 1U)) & 0x5555555555555555ULL;
2175 return (
f | (
s << 1U));
2183 template <
typename T>
2195 template <
typename T>
2206 template <
typename T>
2214 template <
typename T,
size_t NBits>
2224 template <
typename T,
size_t NBits>
2228 template <
typename T,
size_t NBits>
2229 ETL_CONSTEXPR
T make_lsb_mask()
2237 template <
typename T>
2238 ETL_CONSTEXPR T make_lsb_mask(
size_t nbits)
2242 return (nbits == 0U) ?
static_cast<T
>(0)
2243 : static_cast<T>(static_cast<type>(~0) >> (
etl::integral_limits<type>::bits - nbits));
2247 template <
typename T,
size_t NBits>
2257 template <
typename T,
size_t NBits>
2261 template <
typename T>
2262 ETL_CONSTEXPR
T make_msb_mask(
size_t nbits)
2266 return (
nbits == 0
U) ?
static_cast<T>(0)
2271 template <
typename T,
size_t NBits>
2272 ETL_CONSTEXPR T make_msb_mask()
2276 return msb_mask<T, NBits>::value;
2283 template <
typename T>
2301 template <
typename T>
2318 return value & parameter;
2330 template <
typename T>
2347 return value | parameter;
2359 template <
typename T>
2376 return value ^ parameter;
ETL_CONSTEXPR14 uint_least8_t first_set_bit_position(T value)
Definition binary.h:2067
ETL_CONSTEXPR T binary_merge(T first, T second, T mask)
Definition binary.h:458
binary_constant
Definition binary.h:2389
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type count_trailing_ones(T value)
Definition binary.h:1387
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), T >::type reverse_bits(T value)
Definition binary.h:541
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), T >::type gray_to_binary(T value)
Definition binary.h:828
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type parity(T value)
Definition binary.h:1026
ETL_CONSTEXPR14 T rotate_left(T value)
Definition binary.h:116
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint32_t >::type binary_interleave(T first, T second)
Definition binary.h:2132
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_even(T value)
Definition binary.h:2208
ETL_CONSTEXPR14 uint_least8_t first_clear_bit_position(T value)
Definition binary.h:2078
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type count_bits(T value)
Definition binary.h:922
ETL_CONSTEXPR14 TReturn fold_bits(TValue value)
Definition binary.h:242
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type count_trailing_zeros(T value)
Definition binary.h:1141
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type count_leading_ones(T value)
Definition binary.h:1873
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type count_leading_zeros(T value)
Definition binary.h:1627
ETL_CONSTEXPR TResult binary_fill()
Definition binary.h:391
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), T >::type reverse_bytes(T value)
Definition binary.h:739
ETL_CONSTEXPR14 TReturn sign_extend(TValue value)
Definition binary.h:271
bit_constant
Definition binary.h:2653
ETL_CONSTEXPR T binary_to_gray(T value)
Definition binary.h:230
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_odd(T value)
Definition binary.h:2197
ETL_CONSTEXPR14 uint_least8_t first_bit_position(bool state, T value)
Definition binary.h:2090
ETL_CONSTEXPR14 T rotate_right(T value)
Definition binary.h:161
Definition for non-zero NBITS.
Definition binary.h:90
#define ETL_ASSERT(b, e)
Definition error_handler.h:356
Definition exception.h:47
Definition integral_limits.h:516
is_integral
Definition type_traits_generator.h:996
is_signed
Definition type_traits_generator.h:1006
is_unsigned
Definition type_traits_generator.h:1016
make_signed
Definition type_traits_generator.h:1166
make_unsigned
Definition type_traits_generator.h:1176
bitset_ext
Definition absolute.h:38
pair holds two objects of arbitrary type
Definition utility.h:164
Definition functional.h:118