Embedded Template Library 1.0
binary.h
Go to the documentation of this file.
1
2
3/******************************************************************************
4The MIT License(MIT)
5
6Embedded Template Library.
7https://github.com/ETLCPP/etl
8https://www.etlcpp.com
9
10Copyright(c) 2015 John Wellbelove
11
12Permission is hereby granted, free of charge, to any person obtaining a copy
13of this software and associated documentation files(the "Software"), to deal
14in the Software without restriction, including without limitation the rights
15to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
16copies of the Software, and to permit persons to whom the Software is
17furnished to do so, subject to the following conditions :
18
19The above copyright notice and this permission notice shall be included in all
20copies or substantial portions of the Software.
21
22THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
25AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28SOFTWARE.
29******************************************************************************/
30
31#ifndef ETL_BINARY_INCLUDED
32#define ETL_BINARY_INCLUDED
33
37
38#include "platform.h"
39#include "type_traits.h"
40#include "integral_limits.h"
41#include "limits.h"
42#include "static_assert.h"
43#include "log.h"
44#include "power.h"
45#include "smallest.h"
46#include "exception.h"
47#include "error_handler.h"
48
49#if ETL_USING_CPP20 && ETL_USING_STL
50 #include <bit>
51#endif
52
53namespace etl
54{
55 //***************************************************************************
58 //***************************************************************************
60 {
61 public:
62
63 binary_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
64 : exception(reason_, file_name_, line_number_)
65 {
66 }
67 };
68
69 //***************************************************************************
72 //***************************************************************************
74 {
75 public:
76
77 binary_out_of_range(string_type file_name_, numeric_type line_number_)
78 : etl::binary_exception(ETL_ERROR_TEXT("binary:out of range", ETL_BINARY_FILE_ID"A"), file_name_, line_number_)
79 {
80 }
81 };
82
83 //***************************************************************************
86 //***************************************************************************
88 template <size_t NBITS>
90 {
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;
93 };
94
96 template <>
98 {
99 typedef etl::smallest_uint_for_bits<0>::type value_type;
100 static ETL_CONSTANT value_type value = 0;
101 };
102
103 template <size_t NBITS>
104 ETL_CONSTANT typename max_value_for_nbits<NBITS>::value_type max_value_for_nbits<NBITS>::value;
105
106#if ETL_USING_CPP17
107 template <size_t NBITS>
108 inline constexpr typename etl::max_value_for_nbits<NBITS>::value_type max_value_for_nbits_v = max_value_for_nbits<NBITS>::value;
109#endif
110
111 //***************************************************************************
114 //***************************************************************************
115 template <typename T>
116 ETL_CONSTEXPR14 T rotate_left(T value)
117 {
118#if ETL_USING_CPP20 && ETL_USING_STL
119 return std::rotl(value, 1);
120#else
121 ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
122
123 ETL_CONSTANT size_t SHIFT = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits - 1U;
124
125 return (value << 1U) | (value >> SHIFT);
126#endif
127 }
128
129 //***************************************************************************
132 //***************************************************************************
133 template <typename T>
134 ETL_CONSTEXPR14 T rotate_left(T value, size_t distance)
135 {
136#if ETL_USING_CPP20 && ETL_USING_STL
137 return std::rotl(value, distance);
138#else
139 ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
140
141 ETL_CONSTANT size_t BITS = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits;
142 distance %= BITS;
143 const size_t SHIFT = BITS - distance;
144
145 if (SHIFT == BITS)
146 {
147 return value;
148 }
149 else
150 {
151 return (value << distance) | (value >> SHIFT);
152 }
153#endif
154 }
155
156 //***************************************************************************
159 //***************************************************************************
160 template <typename T>
161 ETL_CONSTEXPR14 T rotate_right(T value)
162 {
163#if ETL_USING_CPP20 && ETL_USING_STL
164 return std::rotr(value, 1);
165#else
166 ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
167
168 ETL_CONSTANT size_t SHIFT = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits - 1U;
169
170 return (value >> 1U) | (value << SHIFT);
171#endif
172 }
173
174 //***************************************************************************
177 //***************************************************************************
178 template <typename T>
179 ETL_CONSTEXPR14 T rotate_right(T value, size_t distance)
180 {
181#if ETL_USING_CPP20 && ETL_USING_STL
182 return std::rotr(value, distance);
183#else
184 ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
185
186 ETL_CONSTANT size_t BITS = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits;
187 distance %= BITS;
188 const size_t SHIFT = BITS - distance;
189
190 if (SHIFT == BITS)
191 {
192 return value;
193 }
194 else
195 {
196 return (value >> distance) | (value << SHIFT);
197 }
198#endif
199 }
200
201 //***************************************************************************
205 //***************************************************************************
206 template <typename T>
207 ETL_CONSTEXPR14 T rotate(T value, typename etl::make_signed<size_t>::type distance)
208 {
209 ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
210
211 T result = T();
212
213 if (distance > 0)
214 {
215 result = rotate_left(value, size_t(distance));
216 }
217 else
218 {
219 result = rotate_right(value, size_t(-distance));
220 }
221
222 return result;
223 }
224
225 //***************************************************************************
228 //***************************************************************************
229 template <typename T>
230 ETL_CONSTEXPR T binary_to_gray(T value)
231 {
232 ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
233
234 return (value >> 1U) ^ value;
235 }
236
237 //***************************************************************************
240 //***************************************************************************
241 template <typename TReturn, size_t NBITS, typename TValue>
242 ETL_CONSTEXPR14 TReturn fold_bits(TValue value)
243 {
244 ETL_STATIC_ASSERT(integral_limits<TReturn>::bits >= NBITS, "Return type too small to hold result");
245
246 ETL_CONSTANT TValue mask = etl::power<2, NBITS>::value - 1U;
247 ETL_CONSTANT size_t shift = NBITS;
248
249 // Fold the value down to fit the width.
250 TReturn folded_value = 0;
251
252 // Keep shifting down and XORing the lower bits.
254 {
255 folded_value ^= value & mask;
256 value >>= shift;
257 }
258
259 // Fold the remaining bits.
260 folded_value ^= value & mask;
261
262 return folded_value;
263 }
264
265 //***************************************************************************
269 //***************************************************************************
270 template <typename TReturn, size_t NBITS, typename TValue>
271 ETL_CONSTEXPR14 TReturn sign_extend(TValue value)
272 {
273 ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
274 ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
275 ETL_STATIC_ASSERT(NBITS <= etl::integral_limits<TReturn>::bits, "NBITS too large for return type");
276
277 struct S
278 {
279 signed value : NBITS;
280 } s = {0};
281
282 return (s.value = value);
283 }
284
285 //***************************************************************************
290 //***************************************************************************
291 template <typename TReturn, size_t NBITS, size_t SHIFT, typename TValue>
292 ETL_CONSTEXPR14 TReturn sign_extend(TValue value)
293 {
294 ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
295 ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
296 ETL_STATIC_ASSERT(NBITS <= etl::integral_limits<TReturn>::bits, "NBITS too large for return type");
297 ETL_STATIC_ASSERT(SHIFT <= etl::integral_limits<TReturn>::bits, "SHIFT too large");
298
299 struct S
300 {
301 signed value : NBITS;
302 } s = {0};
303
304 return (s.value = (value >> SHIFT));
305 }
306
307 //***************************************************************************
311 //***************************************************************************
312 template <typename TReturn, typename TValue>
313 ETL_CONSTEXPR14 TReturn sign_extend(TValue value, size_t NBITS)
314 {
315 ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
316 ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
317
319
320 TReturn mask = TReturn(1) << (NBITS - 1);
321 value = value & TValue((TValue(1) << NBITS) - 1);
322
323 return TReturn((value ^ mask) - mask);
324 }
325
326 //***************************************************************************
331 //***************************************************************************
332 template <typename TReturn, typename TValue>
333 ETL_CONSTEXPR14 TReturn sign_extend(TValue value, size_t NBITS, size_t SHIFT)
334 {
335 ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
336 ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
337
339
340 TReturn mask = TReturn(1) << (NBITS - 1);
341 value = (value >> SHIFT) & TValue((TValue(1) << NBITS) - 1);
342
343 return TReturn((value ^ mask) - mask);
344 }
345
346 //***************************************************************************
350 //***************************************************************************
351 template <typename T>
352 ETL_CONSTEXPR14 uint_least8_t first_set_bit_position(T value)
353 {
354 return count_trailing_zeros(value);
355 }
356
357 //***************************************************************************
361 //***************************************************************************
362 template <typename T>
363 ETL_CONSTEXPR14 uint_least8_t first_clear_bit_position(T value)
364 {
365 value = ~value;
366 return count_trailing_zeros(value);
367 }
368
369 //***************************************************************************
373 //***************************************************************************
374 template <typename T>
375 ETL_CONSTEXPR14 uint_least8_t first_bit_position(bool state, T value)
376 {
377 if (!state)
378 {
379 value = ~value;
380 }
381
382 return count_trailing_zeros(value);
383 }
384
385 //***************************************************************************
389 //***************************************************************************
390 template <size_t POSITION>
391 struct bit
392 {
393 typedef typename etl::smallest_uint_for_bits<POSITION + 1>::type value_type;
394 static ETL_CONSTANT value_type value = value_type(1) << POSITION;
395 };
396
397 template <size_t POSITION>
398 ETL_CONSTANT typename bit<POSITION>::value_type bit<POSITION>::value;
399
400#if ETL_USING_CPP17
401 template <size_t POSITION>
402 inline constexpr typename bit<POSITION>::value_type bit_v = bit<POSITION>::value;
403#endif
404
405 //***************************************************************************
408 //***************************************************************************
409 template <typename TResult, typename TValue>
410 ETL_CONSTEXPR TResult binary_fill(TValue value)
411 {
412 ETL_STATIC_ASSERT(sizeof(TResult) >= sizeof(TValue), "Result must be at least as large as the fill value");
413
414 typedef typename etl::make_unsigned<TResult>::type unsigned_r_t;
415 typedef typename etl::make_unsigned<TValue>::type unsigned_v_t;
416
417 return TResult(unsigned_v_t(value) * (unsigned_r_t(~unsigned_r_t(0U)) / unsigned_v_t(~unsigned_v_t(0U))));
418 }
419
420 //***************************************************************************
423 //***************************************************************************
424 template <typename TResult, typename TValue, TValue N>
425 ETL_CONSTEXPR TResult binary_fill()
426 {
427 ETL_STATIC_ASSERT(sizeof(TResult) >= sizeof(TValue), "Result must be at least as large as the fill value");
428
429 typedef typename etl::make_unsigned<TResult>::type unsigned_r_t;
430 typedef typename etl::make_unsigned<TValue>::type unsigned_v_t;
431
432 return TResult(unsigned_v_t(N) * (unsigned_r_t(~unsigned_r_t(0U)) / unsigned_v_t(~unsigned_v_t(0U))));
433 }
434
435#if ETL_USING_8BIT_TYPES
436 //***************************************************************************
439 //***************************************************************************
440 template <typename TValue>
441 ETL_CONSTEXPR14 bool has_zero_byte(TValue value)
442 {
443 typedef typename etl::make_unsigned<TValue>::type unsigned_t;
444 ETL_CONSTEXPR14 const unsigned_t mask = etl::binary_fill<unsigned_t, uint8_t>(0x7FU);
445 const unsigned_t temp = unsigned_t(~((((unsigned_t(value) & mask) + mask) | unsigned_t(value)) | mask));
446
447 return (temp != 0U);
448 }
449
450 //***************************************************************************
453 //***************************************************************************
454 template <typename TValue, TValue N>
455 ETL_CONSTEXPR14 bool has_zero_byte()
456 {
457 typedef typename etl::make_unsigned<TValue>::type unsigned_t;
458 ETL_CONSTEXPR14 const unsigned_t mask = etl::binary_fill<unsigned_t, uint8_t>(0x7FU);
459 const unsigned_t temp = unsigned_t(~((((unsigned_t(N) & mask) + mask) | unsigned_t(N)) | mask));
460
461 return (temp != 0U);
462 }
463
464 //***************************************************************************
467 //***************************************************************************
468 template <typename TValue>
469 ETL_CONSTEXPR14 bool has_byte_n(TValue value, uint8_t n)
470 {
471 return etl::has_zero_byte(TValue(value ^ etl::binary_fill<TValue, uint8_t>(n)));
472 }
473
474 //***************************************************************************
477 //***************************************************************************
478 template <typename TValue, TValue N>
479 ETL_CONSTEXPR14 bool has_byte_n(TValue value)
480 {
481 return etl::has_zero_byte(TValue(value ^ etl::binary_fill<TValue, uint8_t>(N)));
482 }
483#endif
484
485 //***************************************************************************
490 //***************************************************************************
491 template <typename T>
492 ETL_CONSTEXPR T binary_merge(T first, T second, T mask)
493 {
494 return second ^ ((second ^ first) & mask);
495 }
496
497 //***************************************************************************
502 //***************************************************************************
503 template <typename T, T MASK>
504 ETL_CONSTEXPR T binary_merge(T first, T second)
505 {
506 return second ^ ((second ^ first) & MASK);
507 }
508
509 //***************************************************************************
512 //***************************************************************************
513 template <typename T, T Value>
515
516#if ETL_USING_8BIT_TYPES
517 //***************************************************************************
520 //***************************************************************************
521 template <typename T>
522 ETL_CONSTEXPR14
524 reverse_bits(T value)
525 {
526 value = ((value & 0xAAU) >> 1U) | ((value & 0x55U) << 1U);
527 value = ((value & 0xCCU) >> 2U) | ((value & 0x33U) << 2U);
528 value = (value >> 4U) | ((value & 0x0FU) << 4U);
529
530 return value;
531 }
532
533 //***********************************
534 template <uint8_t Value>
535 struct reverse_bits_const<uint8_t, Value>
536 {
537 private:
538
539 static ETL_CONSTANT uint8_t value1 = uint8_t(((Value & 0xAAU) >> 1U) | ((Value & 0x55U) << 1U));
540 static ETL_CONSTANT uint8_t value2 = uint8_t(((value1 & 0xCCU) >> 2U) | ((value1 & 0x33U) << 2U));
541
542 public:
543
544 static ETL_CONSTANT uint8_t value = uint8_t((value2 >> 4U) | ((value2 & 0x0FU) << 4U));
545 };
546
547 template <uint8_t Value>
548 ETL_CONSTANT uint8_t reverse_bits_const<uint8_t, Value>::value;
549
550 //***********************************
551 template <int8_t Value>
552 struct reverse_bits_const<int8_t, Value>
553 {
554 private:
555
556 static ETL_CONSTANT int8_t value1 = int8_t(((Value & 0xAAU) >> 1U) | ((Value & 0x55U) << 1U));
557 static ETL_CONSTANT int8_t value2 = int8_t(((value1 & 0xCCU) >> 2U) | ((value1 & 0x33U) << 2U));
558
559 public:
560
561 static ETL_CONSTANT int8_t value = int8_t((value2 >> 4U) | ((value2 & 0x0FU) << 4U));
562 };
563
564 template <int8_t Value>
565 ETL_CONSTANT int8_t reverse_bits_const<int8_t, Value>::value;
566#endif
567
568 //***************************************************************************
571 //***************************************************************************
572 template <typename T>
573 ETL_CONSTEXPR14
576 {
577 value = ((value & 0xAAAAU) >> 1U) | ((value & 0x5555U) << 1U);
578 value = ((value & 0xCCCCU) >> 2U) | ((value & 0x3333U) << 2U);
579 value = ((value & 0xF0F0U) >> 4U) | ((value & 0x0F0FU) << 4U);
580 value = (value >> 8U) | ((value & 0xFFU) << 8U);
581
582 return value;
583 }
584
585 //***********************************
586 template <uint16_t Value>
587 struct reverse_bits_const<uint16_t, Value>
588 {
589 private:
590
591 static ETL_CONSTANT uint16_t value1 = uint16_t(((Value & 0xAAAAU) >> 1U) | ((Value & 0x5555U) << 1U));
592 static ETL_CONSTANT uint16_t value2 = uint16_t(((value1 & 0xCCCCU) >> 2U) | ((value1 & 0x3333U) << 2U));
593 static ETL_CONSTANT uint16_t value3 = uint16_t(((value2 & 0xF0F0U) >> 4U) | ((value2 & 0x0F0FU) << 4U));
594
595 public:
596
597 static ETL_CONSTANT uint16_t value = uint16_t((value3 >> 8U) | ((value3 & 0xFFU) << 8U));
598 };
599
600 template <uint16_t Value>
601 ETL_CONSTANT uint16_t reverse_bits_const<uint16_t, Value>::value;
602
603 //***********************************
604 template <int16_t Value>
605 struct reverse_bits_const<int16_t, Value>
606 {
607 private:
608
609 static ETL_CONSTANT int16_t value1 = int16_t(((Value & 0xAAAAU) >> 1U) | ((Value & 0x5555U) << 1U));
610 static ETL_CONSTANT int16_t value2 = int16_t(((value1 & 0xCCCCU) >> 2U) | ((value1 & 0x3333U) << 2U));
611 static ETL_CONSTANT int16_t value3 = int16_t(((value2 & 0xF0F0U) >> 4U) | ((value2 & 0x0F0FU) << 4U));
612
613 public:
614
615 static ETL_CONSTANT int16_t value = int16_t((value3 >> 8U) | ((value3 & 0xFFU) << 8U));
616 };
617
618 template <int16_t Value>
620
621 //***************************************************************************
624 //***************************************************************************
625 template <typename T>
626 ETL_CONSTEXPR14
629 {
630 value = ((value & 0xAAAAAAAAUL) >> 1U) | ((value & 0x55555555UL) << 1U);
631 value = ((value & 0xCCCCCCCCUL) >> 2U) | ((value & 0x33333333UL) << 2U);
632 value = ((value & 0xF0F0F0F0UL) >> 4U) | ((value & 0x0F0F0F0FUL) << 4U);
633 value = ((value & 0xFF00FF00UL) >> 8U) | ((value & 0x00FF00FFUL) << 8U);
634 value = (value >> 16U) | ((value & 0xFFFFU) << 16U);
635
636 return value;
637 }
638
639 //***********************************
640 template <uint32_t Value>
641 struct reverse_bits_const<uint32_t, Value>
642 {
643 private:
644
645 static ETL_CONSTANT uint32_t value1 = uint32_t(((Value & 0xAAAAAAAAUL) >> 1U) | ((Value & 0x55555555UL) << 1U));
646 static ETL_CONSTANT uint32_t value2 = uint32_t(((value1 & 0xCCCCCCCCUL) >> 2U) | ((value1 & 0x33333333UL) << 2U));
647 static ETL_CONSTANT uint32_t value3 = uint32_t(((value2 & 0xF0F0F0F0UL) >> 4U) | ((value2 & 0x0F0F0F0FUL) << 4U));
648 static ETL_CONSTANT uint32_t value4 = uint32_t(((value3 & 0xFF00FF00UL) >> 8U) | ((value3 & 0x00FF00FFUL) << 8U));
649
650 public:
651
652 static ETL_CONSTANT uint32_t value = uint32_t((value4 >> 16U) | ((value4 & 0xFFFFU) << 16U));
653 };
654
655 template <uint32_t Value>
656 ETL_CONSTANT uint32_t reverse_bits_const<uint32_t, Value>::value;
657
658 //***********************************
659 template <int32_t Value>
660 struct reverse_bits_const<int32_t, Value>
661 {
662 private:
663
664 static ETL_CONSTANT int32_t value1 = int32_t(((Value & 0xAAAAAAAAUL) >> 1U) | ((Value & 0x55555555UL) << 1U));
665 static ETL_CONSTANT int32_t value2 = int32_t(((value1 & 0xCCCCCCCCUL) >> 2U) | ((value1 & 0x33333333UL) << 2U));
666 static ETL_CONSTANT int32_t value3 = int32_t(((value2 & 0xF0F0F0F0UL) >> 4U) | ((value2 & 0x0F0F0F0FUL) << 4U));
667 static ETL_CONSTANT int32_t value4 = int32_t(((value3 & 0xFF00FF00UL) >> 8U) | ((value3 & 0x00FF00FFUL) << 8U));
668
669 public:
670
671 static ETL_CONSTANT int32_t value = int32_t((value4 >> 16U) | ((value4 & 0xFFFFUL) << 16U));
672 };
673
674 template <int32_t Value>
676
677#if ETL_USING_64BIT_TYPES
678 //***************************************************************************
681 //***************************************************************************
682 template <typename T>
683 ETL_CONSTEXPR14
686 {
687 value = ((value & 0xAAAAAAAAAAAAAAAAULL) >> 1U) | ((value & 0x5555555555555555ULL) << 1U);
688 value = ((value & 0xCCCCCCCCCCCCCCCCULL) >> 2U) | ((value & 0x3333333333333333ULL) << 2U);
689 value = ((value & 0xF0F0F0F0F0F0F0F0ULL) >> 4U) | ((value & 0x0F0F0F0F0F0F0F0FULL) << 4U);
690 value = ((value & 0xFF00FF00FF00FF00ULL) >> 8U) | ((value & 0x00FF00FF00FF00FFULL) << 8U);
691 value = ((value & 0xFFFF0000FFFF0000ULL) >> 16U) | ((value & 0x0000FFFF0000FFFFULL) << 16U);
692 value = (value >> 32U) | ((value & 0xFFFFFFFFULL) << 32U);
693
694 return value;
695 }
696
697 //***********************************
698 template <uint64_t Value>
699 struct reverse_bits_const<uint64_t, Value>
700 {
701 private:
702
703 static ETL_CONSTANT uint64_t value1 = uint64_t(((Value & 0xAAAAAAAAAAAAAAAAULL) >> 1U) | ((Value & 0x5555555555555555ULL) << 1U));
704 static ETL_CONSTANT uint64_t value2 = uint64_t(((value1 & 0xCCCCCCCCCCCCCCCCULL) >> 2U) | ((value1 & 0x3333333333333333ULL) << 2U));
705 static ETL_CONSTANT uint64_t value3 = uint64_t(((value2 & 0xF0F0F0F0F0F0F0F0ULL) >> 4U) | ((value2 & 0x0F0F0F0F0F0F0F0FULL) << 4U));
706 static ETL_CONSTANT uint64_t value4 = uint64_t(((value3 & 0xFF00FF00FF00FF00ULL) >> 8U) | ((value3 & 0x00FF00FF00FF00FFULL) << 8U));
707 static ETL_CONSTANT uint64_t value5 = uint64_t(((value4 & 0xFFFF0000FFFF0000ULL) >> 16U) | ((value4 & 0x0000FFFF0000FFFFULL) << 16U));
708
709 public:
710
711 static ETL_CONSTANT uint64_t value = uint64_t((value5 >> 32U) | ((value5 & 0xFFFFFFFFULL) << 32U));
712 };
713
714 template <uint64_t Value>
715 ETL_CONSTANT uint64_t reverse_bits_const<uint64_t, Value>::value;
716
717 //***********************************
718 template <int64_t Value>
719 struct reverse_bits_const<int64_t, Value>
720 {
721 private:
722
723 static ETL_CONSTANT int64_t value1 = int64_t(((Value & 0xAAAAAAAAAAAAAAAAULL) >> 1U) | ((Value & 0x5555555555555555ULL) << 1U));
724 static ETL_CONSTANT int64_t value2 = int64_t(((value1 & 0xCCCCCCCCCCCCCCCCULL) >> 2U) | ((value1 & 0x3333333333333333ULL) << 2U));
725 static ETL_CONSTANT int64_t value3 = int64_t(((value2 & 0xF0F0F0F0F0F0F0F0ULL) >> 4U) | ((value2 & 0x0F0F0F0F0F0F0F0FULL) << 4U));
726 static ETL_CONSTANT int64_t value4 = int64_t(((value3 & 0xFF00FF00FF00FF00ULL) >> 8U) | ((value3 & 0x00FF00FF00FF00FFULL) << 8U));
727 static ETL_CONSTANT int64_t value5 = int64_t(((value4 & 0xFFFF0000FFFF0000ULL) >> 16U) | ((value4 & 0x0000FFFF0000FFFFULL) << 16U));
728
729 public:
730
731 static ETL_CONSTANT int64_t value = int64_t((value5 >> 32U) | ((value5 & 0xFFFFFFFFULL) << 32U));
732 };
733
734 template <int64_t Value>
736#endif
737
738 //***************************************************************************
741 //***************************************************************************
742 template <typename T>
743 ETL_CONSTEXPR14
746 {
747 typedef typename etl::make_unsigned<T>::type unsigned_t;
748
749 return static_cast<T>(reverse_bits(static_cast<unsigned_t>(value)));
750 }
751
752 //***************************************************************************
755 //***************************************************************************
756#if ETL_USING_8BIT_TYPES
757 template <typename T>
758 ETL_CONSTEXPR14
760 reverse_bytes(T value)
761 {
762 return value;
763 }
764#endif
765
766 //***************************************************************************
769 //***************************************************************************
770 template <typename T>
771 ETL_CONSTEXPR14
774 {
775#if ETL_CPP23_SUPPORTED && ETL_USING_STL
776 return std::byteswap(value);
777#else
778 return (value >> 8U) | (value << 8U);
779#endif
780 }
781
782 //***************************************************************************
785 //***************************************************************************
786 template <typename T>
787 ETL_CONSTEXPR14
790 {
791#if ETL_CPP23_SUPPORTED && ETL_USING_STL
792 return std::byteswap(value);
793#else
794 value = ((value & 0xFF00FF00UL) >> 8U) | ((value & 0x00FF00FFUL) << 8U);
795 value = (value >> 16U) | (value << 16U);
796
797 return value;
798#endif
799 }
800
801#if ETL_USING_64BIT_TYPES
802 //***************************************************************************
805 //***************************************************************************
806 template <typename T>
807 ETL_CONSTEXPR14
810 {
811#if ETL_CPP23_SUPPORTED && ETL_USING_STL
812 return std::byteswap(value);
813#else
814 value = ((value & 0xFF00FF00FF00FF00ULL) >> 8U) | ((value & 0x00FF00FF00FF00FFULL) << 8U);
815 value = ((value & 0xFFFF0000FFFF0000ULL) >> 16U) | ((value & 0x0000FFFF0000FFFFULL) << 16U);
816 value = (value >> 32U) | (value << 32U);
817
818 return value;
819#endif
820 }
821#endif
822
823 //***************************************************************************
826 //***************************************************************************
827 template <typename T>
828 ETL_CONSTEXPR14
831 {
832 typedef typename etl::make_unsigned<T>::type unsigned_t;
833
834 return static_cast<T>(reverse_bytes(static_cast<unsigned_t>(value)));
835 }
836
837#if ETL_USING_8BIT_TYPES
838 //***************************************************************************
841 //***************************************************************************
842 template <typename T>
843 ETL_CONSTEXPR14
845 gray_to_binary(T value)
846 {
847 value ^= (value >> 4U);
848 value ^= (value >> 2U);
849 value ^= (value >> 1U);
850
851 return value;
852 }
853#endif
854
855 //***************************************************************************
858 //***************************************************************************
859 template <typename T>
860 ETL_CONSTEXPR14
863 {
864 value ^= (value >> 8U);
865 value ^= (value >> 4U);
866 value ^= (value >> 2U);
867 value ^= (value >> 1U);
868
869 return value;
870 }
871
872 //***************************************************************************
875 //***************************************************************************
876 template <typename T>
877 ETL_CONSTEXPR14
880 {
881 value ^= (value >> 16U);
882 value ^= (value >> 8U);
883 value ^= (value >> 4U);
884 value ^= (value >> 2U);
885 value ^= (value >> 1U);
886
887 return value;
888 }
889
890#if ETL_USING_64BIT_TYPES
891 //***************************************************************************
894 //***************************************************************************
895 template <typename T>
896 ETL_CONSTEXPR14
899 {
900 value ^= (value >> 32U);
901 value ^= (value >> 16U);
902 value ^= (value >> 8U);
903 value ^= (value >> 4U);
904 value ^= (value >> 2U);
905 value ^= (value >> 1U);
906
907 return value;
908 }
909#endif
910
911 //***************************************************************************
914 //***************************************************************************
915 template <typename T>
916 ETL_CONSTEXPR14
919 {
920 typedef typename etl::make_unsigned<T>::type unsigned_t;
921
922 return static_cast<T>(gray_to_binary(static_cast<unsigned_t>(value)));
923 }
924
925#if ETL_USING_8BIT_TYPES
926 //***************************************************************************
929 //***************************************************************************
930 template <typename T>
931 ETL_CONSTEXPR14
933 count_bits(T value)
934 {
935#if ETL_CPP23_SUPPORTED && ETL_USING_STL
936 return std::popcount(value);
937#else
938 uint32_t count = 0U;
939
940 count = value - ((value >> 1U) & 0x55U);
941 count = ((count >> 2U) & 0x33U) + (count & 0x33U);
942 count = ((count >> 4U) + count) & 0x0FU;
943
944 return uint_least8_t(count);
945#endif
946 }
947#endif
948
949 //***************************************************************************
952 //***************************************************************************
953 template <typename T>
954 ETL_CONSTEXPR14
956 count_bits(T value)
957 {
958#if ETL_USING_CPP20 && ETL_USING_STL
959 return std::popcount(value);
960#else
961 uint32_t count = 0U;
962
963 count = value - ((value >> 1U) & 0x5555U);
964 count = ((count >> 2U) & 0x3333U) + (count & 0x3333U);
965 count = ((count >> 4U) + count) & 0x0F0FU;
966 count = ((count >> 8U) + count) & 0x00FFU;
967
968 return static_cast<uint_least8_t>(count);
969#endif
970 }
971
972 //***************************************************************************
975 //***************************************************************************
976 template <typename T>
977 ETL_CONSTEXPR14
979 count_bits(T value)
980 {
981#if ETL_USING_CPP20 && ETL_USING_STL
982 return std::popcount(value);
983#else
984 uint32_t count = 0U;
985
986 count = value - ((value >> 1U) & 0x55555555UL);
987 count = ((count >> 2U) & 0x33333333UL) + (count & 0x33333333UL);
988 count = ((count >> 4U) + count) & 0x0F0F0F0FUL;
989 count = ((count >> 8U) + count) & 0x00FF00FFUL;
990 count = ((count >> 16U) + count) & 0x0000FFUL;
991
992 return static_cast<uint_least8_t>(count);
993#endif
994 }
995
996#if ETL_USING_64BIT_TYPES
997 //***************************************************************************
1000 //***************************************************************************
1001 template <typename T>
1002 ETL_CONSTEXPR14
1004 count_bits(T value)
1005 {
1006#if ETL_USING_CPP20 && ETL_USING_STL
1007 return std::popcount(value);
1008#else
1009 uint64_t count = 0U;
1010
1011 count = value - ((value >> 1U) & 0x5555555555555555ULL);
1012 count = ((count >> 2U) & 0x3333333333333333ULL) + (count & 0x3333333333333333ULL);
1013 count = ((count >> 4U) + count) & 0x0F0F0F0F0F0F0F0FULL;
1014 count = ((count >> 8U) + count) & 0x00FF00FF00FF00FFULL;
1015 count = ((count >> 16U) + count) & 0x0000FFFF0000FFFFULL;
1016 count = ((count >> 32U) + count) & 0x00000000FFFFFFFFULL;
1017
1018 return static_cast<uint_least8_t>(count);
1019#endif
1020 }
1021#endif
1022
1023 //***************************************************************************
1026 //***************************************************************************
1027 template <typename T>
1028 ETL_CONSTEXPR14
1030 count_bits(T value)
1031 {
1032 typedef typename etl::make_unsigned<T>::type unsigned_t;
1033
1034 return static_cast<T>(count_bits(static_cast<unsigned_t>(value)));
1035 }
1036
1037#if ETL_USING_8BIT_TYPES
1038 //***************************************************************************
1041 //***************************************************************************
1042 template <typename T>
1043 ETL_CONSTEXPR14
1045 parity(T value)
1046 {
1047 value ^= value >> 4U;
1048 value &= 0x0FU;
1049 return (0x6996U >> value) & 1U;
1050 }
1051#endif
1052
1053 //***************************************************************************
1056 //***************************************************************************
1057 template <typename T>
1058 ETL_CONSTEXPR14
1060 parity(T value)
1061 {
1062 value ^= value >> 8U;
1063 value ^= value >> 4U;
1064 value &= 0x0FU;
1065 return (0x6996U >> value) & 1U;
1066 }
1067
1068 //***************************************************************************
1071 //***************************************************************************
1072 template <typename T>
1073 ETL_CONSTEXPR14
1075 parity(T value)
1076 {
1077 value ^= value >> 16U;
1078 value ^= value >> 8U;
1079 value ^= value >> 4U;
1080 value &= 0x0FU;
1081 return (0x6996U >> value) & 1U;
1082 }
1083
1084#if ETL_USING_64BIT_TYPES
1085 //***************************************************************************
1088 //***************************************************************************
1089 template <typename T>
1090 ETL_CONSTEXPR14
1092 parity(T value)
1093 {
1094 value ^= value >> 32U;
1095 value ^= value >> 16U;
1096 value ^= value >> 8U;
1097 value ^= value >> 4U;
1098 value &= 0x0FU;
1099 return (0x69966996UL >> value) & 1U;
1100 }
1101#endif
1102
1103 //***************************************************************************
1106 //***************************************************************************
1107 template <typename T>
1108 ETL_CONSTEXPR14
1110 parity(T value)
1111 {
1112 typedef typename etl::make_unsigned<T>::type unsigned_t;
1113
1114 return static_cast<T>(parity(static_cast<unsigned_t>(value)));
1115 }
1116
1117#if ETL_USING_8BIT_TYPES
1118 //***************************************************************************
1122 //***************************************************************************
1123 template <typename T>
1124 ETL_CONSTEXPR14
1126 count_trailing_zeros(T value)
1127 {
1128#if ETL_USING_CPP20 && ETL_USING_STL
1129 return std::countr_zero(value);
1130#else
1131 uint_least8_t count = 0U;
1132
1133 if (value & 0x1U)
1134 {
1135 count = 0U;
1136 }
1137 else
1138 {
1139 count = 1U;
1140
1141 if ((value & 0xFU) == 0U)
1142 {
1143 value >>= 4U;
1144 count += 4U;
1145 }
1146
1147 if ((value & 0x3U) == 0U)
1148 {
1149 value >>= 2U;
1150 count += 2U;
1151 }
1152
1153 if ((value & 0x1U) == 0U)
1154 {
1155 value >>= 1U;
1156 count += 1U;
1157 }
1158
1159 count -= (value & 0x1U);
1160 }
1161
1162 return count;
1163#endif
1164 }
1165#endif
1166
1167 //***************************************************************************
1171 //***************************************************************************
1172 template <typename T>
1173 ETL_CONSTEXPR14
1176 {
1177#if ETL_USING_CPP20 && ETL_USING_STL
1178 return std::countr_zero(value);
1179#else
1180 uint_least8_t count = 0U;
1181
1182 if (value & 0x1U)
1183 {
1184 count = 0U;
1185 }
1186 else
1187 {
1188 count = 1U;
1189
1190 if ((value & 0xFFU) == 0U)
1191 {
1192 value >>= 8U;
1193 count += 8U;
1194 }
1195
1196 if ((value & 0xFU) == 0U)
1197 {
1198 value >>= 4U;
1199 count += 4U;
1200 }
1201
1202 if ((value & 0x3U) == 0U)
1203 {
1204 value >>= 2U;
1205 count += 2U;
1206 }
1207
1208 if ((value & 0x1U) == 0U)
1209 {
1210 value >>= 1U;
1211 count += 1U;
1212 }
1213
1214 count -= value & 0x1U;
1215 }
1216
1217 return count;
1218#endif
1219 }
1220
1221 //***************************************************************************
1225 //***************************************************************************
1226 template <typename T>
1227 ETL_CONSTEXPR14
1230 {
1231#if ETL_USING_CPP20 && ETL_USING_STL
1232 return std::countr_zero(value);
1233#else
1234 uint_least8_t count = 0U;
1235
1236 if (value & 0x1UL)
1237 {
1238 count = 0U;
1239 }
1240 else
1241 {
1242 count = 1U;
1243
1244 if ((value & 0xFFFFUL) == 0UL)
1245 {
1246 value >>= 16U;
1247 count += 16U;
1248 }
1249
1250 if ((value & 0xFFUL) == 0UL)
1251 {
1252 value >>= 8U;
1253 count += 8U;
1254 }
1255
1256 if ((value & 0xFUL) == 0UL)
1257 {
1258 value >>= 4U;
1259 count += 4U;
1260 }
1261
1262 if ((value & 0x3UL) == 0UL)
1263 {
1264 value >>= 2U;
1265 count += 2U;
1266 }
1267
1268 if ((value & 0x1U) == 0U)
1269 {
1270 value >>= 1U;
1271 count += 1U;
1272 }
1273
1274 count -= value & 0x1UL;
1275 }
1276
1277 return count;
1278#endif
1279 }
1280
1281#if ETL_USING_64BIT_TYPES
1282 //***************************************************************************
1286 //***************************************************************************
1287 template <typename T>
1288 ETL_CONSTEXPR14
1291 {
1292#if ETL_USING_CPP20 && ETL_USING_STL
1293 return std::countr_zero(value);
1294#else
1295 uint_least8_t count = 0U;
1296
1297 if (value & 0x1ULL)
1298 {
1299 count = 0U;
1300 }
1301 else
1302 {
1303 count = 1U;
1304
1305 if ((value & 0xFFFFFFFFULL) == 0ULL)
1306 {
1307 value >>= 32U;
1308 count += 32U;
1309 }
1310
1311 if ((value & 0xFFFFULL) == 0ULL)
1312 {
1313 value >>= 16U;
1314 count += 16U;
1315 }
1316
1317 if ((value & 0xFFULL) == 0ULL)
1318 {
1319 value >>= 8U;
1320 count += 8U;
1321 }
1322
1323 if ((value & 0xFULL) == 0ULL)
1324 {
1325 value >>= 4U;
1326 count += 4U;
1327 }
1328
1329 if ((value & 0x3ULL) == 0ULL)
1330 {
1331 value >>= 2U;
1332 count += 2U;
1333 }
1334
1335 if ((value & 0x1U) == 0U)
1336 {
1337 value >>= 1U;
1338 count += 1U;
1339 }
1340
1341 count -= value & 0x1ULL;
1342 }
1343
1344 return count;
1345#endif
1346 }
1347#endif
1348
1349 //***************************************************************************
1352 //***************************************************************************
1353 template <typename T>
1354 ETL_CONSTEXPR14
1357 {
1358 typedef typename etl::make_unsigned<T>::type unsigned_t;
1359
1360 return static_cast<T>(count_trailing_zeros(static_cast<unsigned_t>(value)));
1361 }
1362
1363#if ETL_USING_8BIT_TYPES
1364 //***************************************************************************
1368 //***************************************************************************
1369 template <typename T>
1370 ETL_CONSTEXPR14
1372 count_trailing_ones(T value)
1373 {
1374#if ETL_USING_CPP20 && ETL_USING_STL
1375 return std::countr_one(value);
1376#else
1377 uint_least8_t count = 0U;
1378
1379 if ((value & 0x1U) == 0x0U)
1380 {
1381 count = 0U;
1382 }
1383 else
1384 {
1385 count = 1U;
1386
1387 if ((value & 0xFU) == 0xFU)
1388 {
1389 value >>= 4U;
1390 count += 4U;
1391 }
1392
1393 if ((value & 0x3U) == 0x3U)
1394 {
1395 value >>= 2U;
1396 count += 2U;
1397 }
1398
1399 if ((value & 0x1U) == 0x1U)
1400 {
1401 value >>= 1U;
1402 count += 1U;
1403 }
1404
1405 count -= ((value & 0x1U) == 0x0U);
1406 }
1407
1408 return count;
1409#endif
1410 }
1411#endif
1412
1413 //***************************************************************************
1417 //***************************************************************************
1418 template <typename T>
1419 ETL_CONSTEXPR14
1422 {
1423#if ETL_USING_CPP20 && ETL_USING_STL
1424 return std::countr_one(value);
1425#else
1426 uint_least8_t count = 0U;
1427
1428 if ((value & 0x1U) == 0x0U)
1429 {
1430 count = 0U;
1431 }
1432 else
1433 {
1434 count = 1U;
1435
1436 if ((value & 0xFFU) == 0xFFU)
1437 {
1438 value >>= 8U;
1439 count += 8U;
1440 }
1441
1442 if ((value & 0xFU) == 0xFU)
1443 {
1444 value >>= 4U;
1445 count += 4U;
1446 }
1447
1448 if ((value & 0x3U) == 0x3U)
1449 {
1450 value >>= 2U;
1451 count += 2U;
1452 }
1453
1454 if ((value & 0x1U) == 0x1U)
1455 {
1456 value >>= 1U;
1457 count += 1U;
1458 }
1459
1460 count -= ((value & 0x1U) == 0x0U);
1461 }
1462
1463 return count;
1464#endif
1465 }
1466
1467 //***************************************************************************
1471 //***************************************************************************
1472 template <typename T>
1473 ETL_CONSTEXPR14
1476 {
1477#if ETL_USING_CPP20 && ETL_USING_STL
1478 return std::countr_one(value);
1479#else
1480 uint_least8_t count = 0U;
1481
1482 if ((value & 0x1UL) == 0x0UL)
1483 {
1484 count = 0U;
1485 }
1486 else
1487 {
1488 count = 1U;
1489
1490 if ((value & 0xFFFFUL) == 0xFFFFUL)
1491 {
1492 value >>= 16U;
1493 count += 16U;
1494 }
1495
1496 if ((value & 0xFFUL) == 0xFFUL)
1497 {
1498 value >>= 8U;
1499 count += 8U;
1500 }
1501
1502 if ((value & 0xFUL) == 0xFUL)
1503 {
1504 value >>= 4U;
1505 count += 4U;
1506 }
1507
1508 if ((value & 0x3UL) == 0x3UL)
1509 {
1510 value >>= 2U;
1511 count += 2U;
1512 }
1513
1514 if ((value & 0x1UL) == 0x1UL)
1515 {
1516 value >>= 1U;
1517 count += 1U;
1518 }
1519
1520 count -= ((value & 0x1UL) == 0x0UL);
1521 }
1522
1523 return count;
1524#endif
1525 }
1526
1527#if ETL_USING_64BIT_TYPES
1528 //***************************************************************************
1532 //***************************************************************************
1533 template <typename T>
1534 ETL_CONSTEXPR14
1537 {
1538#if ETL_USING_CPP20 && ETL_USING_STL
1539 return std::countr_one(value);
1540#else
1541 uint_least8_t count = 0U;
1542
1543 if ((value & 0x1ULL) == 0x0ULL)
1544 {
1545 count = 0U;
1546 }
1547 else
1548 {
1549 count = 1U;
1550
1551 if ((value & 0xFFFFULL) == 0xFFFFULL)
1552 {
1553 value >>= 16U;
1554 count += 16U;
1555 }
1556
1557 if ((value & 0xFFULL) == 0xFFULL)
1558 {
1559 value >>= 8U;
1560 count += 8U;
1561 }
1562
1563 if ((value & 0xFULL) == 0xFULL)
1564 {
1565 value >>= 4U;
1566 count += 4U;
1567 }
1568
1569 if ((value & 0x3ULL) == 0x3ULL)
1570 {
1571 value >>= 2U;
1572 count += 2U;
1573 }
1574
1575 if ((value & 0x1ULL) == 0x1ULL)
1576 {
1577 value >>= 1U;
1578 count += 1U;
1579 }
1580
1581 count -= ((value & 0x1ULL) == 0x0ULL);
1582 }
1583
1584 return count;
1585#endif
1586 }
1587#endif
1588
1589 //***************************************************************************
1592 //***************************************************************************
1593 template <typename T>
1594 ETL_CONSTEXPR14
1597 {
1598 typedef typename etl::make_unsigned<T>::type unsigned_t;
1599
1600 return static_cast<T>(count_trailing_ones(static_cast<unsigned_t>(value)));
1601 }
1602
1603#if ETL_USING_8BIT_TYPES
1604 //***************************************************************************
1608 //***************************************************************************
1609 template <typename T>
1610 ETL_CONSTEXPR14
1612 count_leading_zeros(T value)
1613 {
1614#if ETL_USING_CPP20 && ETL_USING_STL
1615 return std::countl_zero(value);
1616#else
1617 uint_least8_t count = 0U;
1618
1619 if (value & 0x80U)
1620 {
1621 count = 0U;
1622 }
1623 else
1624 {
1625 count = 1U;
1626
1627 if ((value & 0xF0U) == 0U)
1628 {
1629 value <<= 4U;
1630 count += 4U;
1631 }
1632
1633 if ((value & 0xC0U) == 0U)
1634 {
1635 value <<= 2U;
1636 count += 2U;
1637 }
1638
1639 if ((value & 0x80U) == 0U)
1640 {
1641 value <<= 1U;
1642 count += 1U;
1643 }
1644
1645 count -= ((value & 0x80U) == 0x80U);
1646 }
1647
1648 return count;
1649#endif
1650 }
1651#endif
1652
1653 //***************************************************************************
1657 //***************************************************************************
1658 template <typename T>
1659 ETL_CONSTEXPR14
1662 {
1663#if ETL_USING_CPP20 && ETL_USING_STL
1664 return std::countl_zero(value);
1665#else
1666 uint_least8_t count = 0U;
1667
1668 if (value & 0x8000U)
1669 {
1670 count = 0U;
1671 }
1672 else
1673 {
1674 count = 1U;
1675
1676 if ((value & 0xFF00U) == 0U)
1677 {
1678 value <<= 8U;
1679 count += 8U;
1680 }
1681
1682 if ((value & 0xF000U) == 0U)
1683 {
1684 value <<= 4U;
1685 count += 4U;
1686 }
1687
1688 if ((value & 0xC000U) == 0U)
1689 {
1690 value <<= 2U;
1691 count += 2U;
1692 }
1693
1694 if ((value & 0x8000U) == 0U)
1695 {
1696 value <<= 1U;
1697 count += 1U;
1698 }
1699
1700 count -= ((value & 0x8000U) == 0x8000U);
1701 }
1702
1703 return count;
1704#endif
1705 }
1706
1707 //***************************************************************************
1711 //***************************************************************************
1712 template <typename T>
1713 ETL_CONSTEXPR14
1716 {
1717#if ETL_USING_CPP20 && ETL_USING_STL
1718 return std::countl_zero(value);
1719#else
1720 uint_least8_t count = 0U;
1721
1722 if (value & 0x80000000UL)
1723 {
1724 count = 0U;
1725 }
1726 else
1727 {
1728 count = 1U;
1729
1730 if ((value & 0xFFFF0000UL) == 0U)
1731 {
1732 value <<= 16U;
1733 count += 16U;
1734 }
1735
1736 if ((value & 0xFF000000UL) == 0U)
1737 {
1738 value <<= 8U;
1739 count += 8U;
1740 }
1741
1742 if ((value & 0xF0000000UL) == 0U)
1743 {
1744 value <<= 4U;
1745 count += 4U;
1746 }
1747
1748 if ((value & 0xC0000000UL) == 0U)
1749 {
1750 value <<= 2U;
1751 count += 2U;
1752 }
1753
1754 if ((value & 0x80000000UL) == 0U)
1755 {
1756 value <<= 1U;
1757 count += 1U;
1758 }
1759
1760 count -= ((value & 0x80000000UL) == 0x80000000UL);
1761 }
1762
1763 return count;
1764#endif
1765 }
1766
1767#if ETL_USING_64BIT_TYPES
1768 //***************************************************************************
1772 //***************************************************************************
1773 template <typename T>
1774 ETL_CONSTEXPR14
1777 {
1778#if ETL_USING_CPP20 && ETL_USING_STL
1779 return std::countl_zero(value);
1780#else
1781 uint_least8_t count = 0U;
1782
1783 if (value & 0x8000000000000000ULL)
1784 {
1785 count = 0U;
1786 }
1787 else
1788 {
1789 count = 1U;
1790
1791 if ((value & 0xFFFFFFFFF0000000ULL) == 0U)
1792 {
1793 value <<= 32U;
1794 count += 32U;
1795 }
1796
1797 if ((value & 0xFFFF000000000000ULL) == 0U)
1798 {
1799 value <<= 16U;
1800 count += 16U;
1801 }
1802
1803 if ((value & 0xFF00000000000000ULL) == 0U)
1804 {
1805 value <<= 8U;
1806 count += 8U;
1807 }
1808
1809 if ((value & 0xF000000000000000ULL) == 0U)
1810 {
1811 value <<= 4U;
1812 count += 4U;
1813 }
1814
1815 if ((value & 0xC000000000000000ULL) == 0U)
1816 {
1817 value <<= 2U;
1818 count += 2U;
1819 }
1820
1821 if ((value & 0x8000000000000000ULL) == 0U)
1822 {
1823 value <<= 1U;
1824 count += 1U;
1825 }
1826
1827 count -= ((value & 0x8000000000000000ULL) == 0x8000000000000000ULL);
1828 }
1829
1830 return count;
1831#endif
1832 }
1833#endif
1834
1835 //***************************************************************************
1838 //***************************************************************************
1839 template <typename T>
1840 ETL_CONSTEXPR14
1843 {
1844 typedef typename etl::make_unsigned<T>::type unsigned_t;
1845
1846 return static_cast<T>(count_trailing_ones(static_cast<unsigned_t>(value)));
1847 }
1848
1849#if ETL_USING_8BIT_TYPES
1850 //***************************************************************************
1854 //***************************************************************************
1855 template <typename T>
1856 ETL_CONSTEXPR14
1858 count_leading_ones(T value)
1859 {
1860#if ETL_USING_CPP20 && ETL_USING_STL
1861 return std::countl_one(value);
1862#else
1863 uint_least8_t count = 0U;
1864
1865 if ((value & 0x80U) == 0U)
1866 {
1867 count = 0U;
1868 }
1869 else
1870 {
1871 count = 1U;
1872
1873 if ((value & 0xF0U) == 0xF0U)
1874 {
1875 value <<= 4U;
1876 count += 4U;
1877 }
1878
1879 if ((value & 0xC0U) == 0xC0U)
1880 {
1881 value <<= 2U;
1882 count += 2U;
1883 }
1884
1885 if ((value & 0x80U) == 0x80U)
1886 {
1887 value <<= 1U;
1888 count += 1U;
1889 }
1890
1891 count -= ((value & 0x80U) == 0x0U);
1892 }
1893
1894 return count;
1895#endif
1896 }
1897#endif
1898
1899 //***************************************************************************
1903 //***************************************************************************
1904 template <typename T>
1905 ETL_CONSTEXPR14
1908 {
1909#if ETL_USING_CPP20 && ETL_USING_STL
1910 return std::countl_one(value);
1911#else
1912 uint_least8_t count = 0U;
1913
1914 if ((value & 0x8000U) == 0U)
1915 {
1916 count = 0U;
1917 }
1918 else
1919 {
1920 count = 1U;
1921
1922 if ((value & 0xFF00U) == 0xFF00U)
1923 {
1924 value <<= 8U;
1925 count += 8U;
1926 }
1927
1928 if ((value & 0xF000U) == 0xF000U)
1929 {
1930 value <<= 4U;
1931 count += 4U;
1932 }
1933
1934 if ((value & 0xC000U) == 0xC000U)
1935 {
1936 value <<= 2U;
1937 count += 2U;
1938 }
1939
1940 if ((value & 0x8000U) == 0x8000U)
1941 {
1942 value <<= 1U;
1943 count += 1U;
1944 }
1945
1946 count -= ((value & 0x8000U) == 0U);
1947 }
1948
1949 return count;
1950#endif
1951 }
1952
1953 //***************************************************************************
1957 //***************************************************************************
1958 template <typename T>
1959 ETL_CONSTEXPR14
1962 {
1963#if ETL_USING_CPP20 && ETL_USING_STL
1964 return std::countl_one(value);
1965#else
1966 uint_least8_t count = 0U;
1967
1968 if ((value & 0x80000000UL) == 0UL)
1969 {
1970 count = 0U;
1971 }
1972 else
1973 {
1974 count = 1U;
1975
1976 if ((value & 0xFFFF0000UL) == 0xFFFF0000UL)
1977 {
1978 value <<= 8U;
1979 count += 8U;
1980 }
1981
1982 if ((value & 0xFF000000UL) == 0xFF000000UL)
1983 {
1984 value <<= 8U;
1985 count += 8U;
1986 }
1987
1988 if ((value & 0xF0000000UL) == 0xF0000000UL)
1989 {
1990 value <<= 4U;
1991 count += 4U;
1992 }
1993
1994 if ((value & 0xC0000000UL) == 0xC0000000UL)
1995 {
1996 value <<= 2U;
1997 count += 2U;
1998 }
1999
2000 if ((value & 0x80000000UL) == 0x80000000UL)
2001 {
2002 value <<= 1U;
2003 count += 1U;
2004 }
2005
2006 count -= ((value & 0x80000000UL) == 0UL);
2007 }
2008
2009 return count;
2010#endif
2011 }
2012
2013#if ETL_USING_64BIT_TYPES
2014 //***************************************************************************
2018 //***************************************************************************
2019 template <typename T>
2020 ETL_CONSTEXPR14
2023 {
2024#if ETL_USING_CPP20 && ETL_USING_STL
2025 return std::countl_one(value);
2026#else
2027 uint_least8_t count = 0U;
2028
2029 if ((value & 0x8000000000000000ULL) == 0ULL)
2030 {
2031 count = 0U;
2032 }
2033 else
2034 {
2035 count = 1U;
2036
2037 if ((value & 0xFFFFFFFF00000000ULL) == 0xFFFFFFFF00000000ULL)
2038 {
2039 value <<= 8U;
2040 count += 8U;
2041 }
2042
2043 if ((value & 0xFFFF000000000000ULL) == 0xFFFF000000000000ULL)
2044 {
2045 value <<= 8U;
2046 count += 8U;
2047 }
2048
2049 if ((value & 0xFF00000000000000ULL) == 0xFF00000000000000ULL)
2050 {
2051 value <<= 8U;
2052 count += 8U;
2053 }
2054
2055 if ((value & 0xF000000000000000ULL) == 0xF000000000000000ULL)
2056 {
2057 value <<= 4U;
2058 count += 4U;
2059 }
2060
2061 if ((value & 0xC000000000000000ULL) == 0xC000000000000000ULL)
2062 {
2063 value <<= 2U;
2064 count += 2U;
2065 }
2066
2067 if ((value & 0x8000000000000000ULL) == 0x8000000000000000ULL)
2068 {
2069 value <<= 1U;
2070 count += 1U;
2071 }
2072
2073 count -= ((value & 0x8000000000000000ULL) == 0ULL);
2074 }
2075
2076 return count;
2077#endif
2078 }
2079#endif
2080
2081 //***************************************************************************
2084 //***************************************************************************
2085 template <typename T>
2086 ETL_CONSTEXPR14
2089 {
2090 typedef typename etl::make_unsigned<T>::type unsigned_t;
2091
2092 return static_cast<T>(count_leading_ones(static_cast<unsigned_t>(value)));
2093 }
2094
2095#if ETL_USING_8BIT_TYPES
2096 //*****************************************************************************
2099 //*****************************************************************************
2100 template <typename T>
2101 ETL_CONSTEXPR14
2103 binary_interleave(T first, T second)
2104 {
2105 uint16_t f = uint16_t(first);
2106 uint16_t s = uint16_t(second);
2107
2108 f = (f | (f << 4U)) & 0x0F0FU;
2109 f = (f | (f << 2U)) & 0x3333U;
2110 f = (f | (f << 1U)) & 0x5555U;
2111
2112 s = (s | (s << 4U)) & 0x0F0FU;
2113 s = (s | (s << 2U)) & 0x3333U;
2114 s = (s | (s << 1U)) & 0x5555U;
2115
2116 return (f | (s << 1U));
2117 }
2118#endif
2119
2120 //*****************************************************************************
2123 //*****************************************************************************
2124 template <typename T>
2125 ETL_CONSTEXPR14
2127 binary_interleave(T first, T second)
2128 {
2129 uint32_t f = uint32_t(first);
2130 uint32_t s = uint32_t(second);
2131
2132 f = (f | (f << 8U)) & 0x00FF00FFUL;
2133 f = (f | (f << 4U)) & 0x0F0F0F0FUL;
2134 f = (f | (f << 2U)) & 0x33333333UL;
2135 f = (f | (f << 1U)) & 0x55555555UL;
2136
2137 s = (s | (s << 8U)) & 0x00FF00FFUL;
2138 s = (s | (s << 4U)) & 0x0F0F0F0FUL;
2139 s = (s | (s << 2U)) & 0x33333333UL;
2140 s = (s | (s << 1U)) & 0x55555555UL;
2141
2142 return (f | (s << 1U));
2143 }
2144
2145#if ETL_USING_64BIT_TYPES
2146 //*****************************************************************************
2149 //*****************************************************************************
2150 template <typename T>
2151 ETL_CONSTEXPR14
2153 binary_interleave(T first, T second)
2154 {
2155 uint64_t f = uint64_t(first);
2156 uint64_t s = uint64_t(second);
2157
2158 f = (f | (f << 16U)) & 0x0000FFFF0000FFFFULL;
2159 f = (f | (f << 8U)) & 0x00FF00FF00FF00FFULL;
2160 f = (f | (f << 4U)) & 0x0F0F0F0F0F0F0F0FULL;
2161 f = (f | (f << 2U)) & 0x3333333333333333ULL;
2162 f = (f | (f << 1U)) & 0x5555555555555555ULL;
2163
2164 s = (s | (s << 16U)) & 0x0000FFFF0000FFFFULL;
2165 s = (s | (s << 8U)) & 0x00FF00FF00FF00FFULL;
2166 s = (s | (s << 4U)) & 0x0F0F0F0F0F0F0F0FULL;
2167 s = (s | (s << 2U)) & 0x3333333333333333ULL;
2168 s = (s | (s << 1U)) & 0x5555555555555555ULL;
2169
2170 return (f | (s << 1U));
2171 }
2172#endif
2173
2174 //*****************************************************************************
2177 //*****************************************************************************
2178 template <typename T>
2179 ETL_CONSTEXPR14
2181 binary_interleave(T first, T second)
2182 {
2183 return int64_t(binary_interleave(uint16_t(first), uint16_t(second)));
2184 }
2185
2186 //***************************************************************************
2189 //***************************************************************************
2190 template <typename T>
2191 ETL_CONSTEXPR typename etl::enable_if<etl::is_integral<T>::value, bool>::type
2192 is_odd(T value)
2193 {
2194 return ((static_cast<typename etl::make_unsigned<T>::type>(value) & 1U) != 0U);
2195 }
2196
2197 //***************************************************************************
2200 //***************************************************************************
2201 template <typename T>
2202 ETL_CONSTEXPR typename etl::enable_if<etl::is_integral<T>::value, bool>::type
2203 is_even(T value)
2204 {
2205 return ((static_cast<typename etl::make_unsigned<T>::type>(value) & 1U) == 0U);
2206 }
2207
2208 //***********************************
2209 template <typename T, size_t NBits>
2211 {
2212 public:
2213
2214 static ETL_CONSTANT T value = static_cast<T>(etl::max_value_for_nbits<NBits>::value);
2215 };
2216
2217 template <typename T, size_t NBits>
2218 ETL_CONSTANT T lsb_mask<T, NBits>::value;
2219
2220 //***********************************
2221 template <typename T>
2222 ETL_CONSTEXPR14 T make_lsb_mask(size_t nbits)
2223 {
2224 typedef typename etl::make_unsigned<T>::type type;
2225
2226 return (nbits == etl::integral_limits<type>::bits) ? static_cast<T>(etl::integral_limits<type>::max)
2227 : static_cast<T>((static_cast<type>(1U) << nbits) - 1U);
2228 }
2229
2230 //***********************************
2231 template <typename T, size_t NBits>
2233 {
2234 public:
2235
2236 static ETL_CONSTANT T value = static_cast<T>(etl::reverse_bits_const<T, lsb_mask<T, NBits>::value>::value);
2237 };
2238
2239 template <typename T, size_t NBits>
2240 ETL_CONSTANT T msb_mask<T, NBits>::value;
2241
2242 //***********************************
2243 template <typename T>
2244 ETL_CONSTEXPR14 T make_msb_mask(size_t nbits)
2245 {
2246 return static_cast<T>(etl::reverse_bits(make_lsb_mask<T>(nbits)));
2247 }
2248
2249 //***************************************************************************
2252 //***************************************************************************
2254 {
2255 b00000000 = 0U,
2256 b00000001 = 1U,
2257 b00000010 = 2U,
2258 b00000011 = 3U,
2259 b00000100 = 4U,
2260 b00000101 = 5U,
2261 b00000110 = 6U,
2262 b00000111 = 7U,
2263 b00001000 = 8U,
2264 b00001001 = 9U,
2265 b00001010 = 10U,
2266 b00001011 = 11U,
2267 b00001100 = 12U,
2268 b00001101 = 13U,
2269 b00001110 = 14U,
2270 b00001111 = 15U,
2271 b00010000 = 16U,
2272 b00010001 = 17U,
2273 b00010010 = 18U,
2274 b00010011 = 19U,
2275 b00010100 = 20U,
2276 b00010101 = 21U,
2277 b00010110 = 22U,
2278 b00010111 = 23U,
2279 b00011000 = 24U,
2280 b00011001 = 25U,
2281 b00011010 = 26U,
2282 b00011011 = 27U,
2283 b00011100 = 28U,
2284 b00011101 = 29U,
2285 b00011110 = 30U,
2286 b00011111 = 31U,
2287 b00100000 = 32U,
2288 b00100001 = 33U,
2289 b00100010 = 34U,
2290 b00100011 = 35U,
2291 b00100100 = 36U,
2292 b00100101 = 37U,
2293 b00100110 = 38U,
2294 b00100111 = 39U,
2295 b00101000 = 40U,
2296 b00101001 = 41U,
2297 b00101010 = 42U,
2298 b00101011 = 43U,
2299 b00101100 = 44U,
2300 b00101101 = 45U,
2301 b00101110 = 46U,
2302 b00101111 = 47U,
2303 b00110000 = 48U,
2304 b00110001 = 49U,
2305 b00110010 = 50U,
2306 b00110011 = 51U,
2307 b00110100 = 52U,
2308 b00110101 = 53U,
2309 b00110110 = 54U,
2310 b00110111 = 55U,
2311 b00111000 = 56U,
2312 b00111001 = 57U,
2313 b00111010 = 58U,
2314 b00111011 = 59U,
2315 b00111100 = 60U,
2316 b00111101 = 61U,
2317 b00111110 = 62U,
2318 b00111111 = 63U,
2319 b01000000 = 64U,
2320 b01000001 = 65U,
2321 b01000010 = 66U,
2322 b01000011 = 67U,
2323 b01000100 = 68U,
2324 b01000101 = 69U,
2325 b01000110 = 70U,
2326 b01000111 = 71U,
2327 b01001000 = 72U,
2328 b01001001 = 73U,
2329 b01001010 = 74U,
2330 b01001011 = 75U,
2331 b01001100 = 76U,
2332 b01001101 = 77U,
2333 b01001110 = 78U,
2334 b01001111 = 79U,
2335 b01010000 = 80U,
2336 b01010001 = 81U,
2337 b01010010 = 82U,
2338 b01010011 = 83U,
2339 b01010100 = 84U,
2340 b01010101 = 85U,
2341 b01010110 = 86U,
2342 b01010111 = 87U,
2343 b01011000 = 88U,
2344 b01011001 = 89U,
2345 b01011010 = 90U,
2346 b01011011 = 91U,
2347 b01011100 = 92U,
2348 b01011101 = 93U,
2349 b01011110 = 94U,
2350 b01011111 = 95U,
2351 b01100000 = 96U,
2352 b01100001 = 97U,
2353 b01100010 = 98U,
2354 b01100011 = 99U,
2355 b01100100 = 100U,
2356 b01100101 = 101U,
2357 b01100110 = 102U,
2358 b01100111 = 103U,
2359 b01101000 = 104U,
2360 b01101001 = 105U,
2361 b01101010 = 106U,
2362 b01101011 = 107U,
2363 b01101100 = 108U,
2364 b01101101 = 109U,
2365 b01101110 = 110U,
2366 b01101111 = 111U,
2367 b01110000 = 112U,
2368 b01110001 = 113U,
2369 b01110010 = 114U,
2370 b01110011 = 115U,
2371 b01110100 = 116U,
2372 b01110101 = 117U,
2373 b01110110 = 118U,
2374 b01110111 = 119U,
2375 b01111000 = 120U,
2376 b01111001 = 121U,
2377 b01111010 = 122U,
2378 b01111011 = 123U,
2379 b01111100 = 124U,
2380 b01111101 = 125U,
2381 b01111110 = 126U,
2382 b01111111 = 127U,
2383 b10000000 = 128U,
2384 b10000001 = 129U,
2385 b10000010 = 130U,
2386 b10000011 = 131U,
2387 b10000100 = 132U,
2388 b10000101 = 133U,
2389 b10000110 = 134U,
2390 b10000111 = 135U,
2391 b10001000 = 136U,
2392 b10001001 = 137U,
2393 b10001010 = 138U,
2394 b10001011 = 139U,
2395 b10001100 = 140U,
2396 b10001101 = 141U,
2397 b10001110 = 142U,
2398 b10001111 = 143U,
2399 b10010000 = 144U,
2400 b10010001 = 145U,
2401 b10010010 = 146U,
2402 b10010011 = 147U,
2403 b10010100 = 148U,
2404 b10010101 = 149U,
2405 b10010110 = 150U,
2406 b10010111 = 151U,
2407 b10011000 = 152U,
2408 b10011001 = 153U,
2409 b10011010 = 154U,
2410 b10011011 = 155U,
2411 b10011100 = 156U,
2412 b10011101 = 157U,
2413 b10011110 = 158U,
2414 b10011111 = 159U,
2415 b10100000 = 160U,
2416 b10100001 = 161U,
2417 b10100010 = 162U,
2418 b10100011 = 163U,
2419 b10100100 = 164U,
2420 b10100101 = 165U,
2421 b10100110 = 166U,
2422 b10100111 = 167U,
2423 b10101000 = 168U,
2424 b10101001 = 169U,
2425 b10101010 = 170U,
2426 b10101011 = 171U,
2427 b10101100 = 172U,
2428 b10101101 = 173U,
2429 b10101110 = 174U,
2430 b10101111 = 175U,
2431 b10110000 = 176U,
2432 b10110001 = 177U,
2433 b10110010 = 178U,
2434 b10110011 = 179U,
2435 b10110100 = 180U,
2436 b10110101 = 181U,
2437 b10110110 = 182U,
2438 b10110111 = 183U,
2439 b10111000 = 184U,
2440 b10111001 = 185U,
2441 b10111010 = 186U,
2442 b10111011 = 187U,
2443 b10111100 = 188U,
2444 b10111101 = 189U,
2445 b10111110 = 190U,
2446 b10111111 = 191U,
2447 b11000000 = 192U,
2448 b11000001 = 193U,
2449 b11000010 = 194U,
2450 b11000011 = 195U,
2451 b11000100 = 196U,
2452 b11000101 = 197U,
2453 b11000110 = 198U,
2454 b11000111 = 199U,
2455 b11001000 = 200U,
2456 b11001001 = 201U,
2457 b11001010 = 202U,
2458 b11001011 = 203U,
2459 b11001100 = 204U,
2460 b11001101 = 205U,
2461 b11001110 = 206U,
2462 b11001111 = 207U,
2463 b11010000 = 208U,
2464 b11010001 = 209U,
2465 b11010010 = 210U,
2466 b11010011 = 211U,
2467 b11010100 = 212U,
2468 b11010101 = 213U,
2469 b11010110 = 214U,
2470 b11010111 = 215U,
2471 b11011000 = 216U,
2472 b11011001 = 217U,
2473 b11011010 = 218U,
2474 b11011011 = 219U,
2475 b11011100 = 220U,
2476 b11011101 = 221U,
2477 b11011110 = 222U,
2478 b11011111 = 223U,
2479 b11100000 = 224U,
2480 b11100001 = 225U,
2481 b11100010 = 226U,
2482 b11100011 = 227U,
2483 b11100100 = 228U,
2484 b11100101 = 229U,
2485 b11100110 = 230U,
2486 b11100111 = 231U,
2487 b11101000 = 232U,
2488 b11101001 = 233U,
2489 b11101010 = 234U,
2490 b11101011 = 235U,
2491 b11101100 = 236U,
2492 b11101101 = 237U,
2493 b11101110 = 238U,
2494 b11101111 = 239U,
2495 b11110000 = 240U,
2496 b11110001 = 241U,
2497 b11110010 = 242U,
2498 b11110011 = 243U,
2499 b11110100 = 244U,
2500 b11110101 = 245U,
2501 b11110110 = 246U,
2502 b11110111 = 247U,
2503 b11111000 = 248U,
2504 b11111001 = 249U,
2505 b11111010 = 250U,
2506 b11111011 = 251U,
2507 b11111100 = 252U,
2508 b11111101 = 253U,
2509 b11111110 = 254U,
2510 b11111111 = 255U
2511 };
2512
2513 //***************************************************************************
2516 //***************************************************************************
2518 {
2519 b0 = 0x1UL,
2520 b1 = 0x2UL,
2521 b2 = 0x4UL,
2522 b3 = 0x8UL,
2523 b4 = 0x10UL,
2524 b5 = 0x20UL,
2525 b6 = 0x40UL,
2526 b7 = 0x80UL,
2527 b8 = 0x100UL,
2528 b9 = 0x200UL,
2529 b10 = 0x400UL,
2530 b11 = 0x800UL,
2531 b12 = 0x1000UL,
2532 b13 = 0x2000UL,
2533 b14 = 0x4000UL,
2534 b15 = 0x8000UL,
2535 b16 = 0x10000UL,
2536 b17 = 0x20000UL,
2537 b18 = 0x40000UL,
2538 b19 = 0x80000UL,
2539 b20 = 0x100000UL,
2540 b21 = 0x200000UL,
2541 b22 = 0x400000UL,
2542 b23 = 0x800000UL,
2543 b24 = 0x1000000UL,
2544 b25 = 0x2000000UL,
2545 b26 = 0x4000000UL,
2546 b27 = 0x8000000UL,
2547 b28 = 0x10000000UL,
2548 b29 = 0x20000000UL,
2549 b30 = 0x40000000UL,
2550 b31 = 0x80000000UL
2551 };
2552}
2553
2554#endif
Definition: binary.h:2211
Definition: binary.h:2233
Definition: binary.h:60
Definition: binary.h:74
ETL_CONSTEXPR TResult binary_fill(TValue value)
Definition: binary.h:410
ETL_CONSTEXPR14 uint_least8_t first_set_bit_position(T value)
Definition: binary.h:352
ETL_CONSTEXPR T binary_merge(T first, T second, T mask)
Definition: binary.h:492
binary_constant
Definition: binary.h:2254
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:1421
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:575
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:862
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:1060
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:2127
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_even(T value)
Definition: binary.h:2203
ETL_CONSTEXPR14 uint_least8_t first_clear_bit_position(T value)
Definition: binary.h:363
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:956
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:1175
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:1907
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:1661
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:773
ETL_CONSTEXPR14 TReturn sign_extend(TValue value)
Definition: binary.h:271
bit_constant
Definition: binary.h:2518
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:2192
ETL_CONSTEXPR14 uint_least8_t first_bit_position(bool state, T value)
Definition: binary.h:375
ETL_CONSTEXPR14 T rotate_right(T value)
Definition: binary.h:161
Definition: binary.h:392
Definition for non-zero NBITS.
Definition: binary.h:90
Definition: binary.h:514
#define ETL_ASSERT(b, e)
Definition: error_handler.h:316
ETL_CONSTEXPR exception(string_type reason_, string_type, numeric_type line_)
Constructor.
Definition: exception.h:69
Definition: exception.h:47
Definition: integral_limits.h:468
Definition: power.h:62
enable_if
Definition: type_traits_generator.h:1191
is_integral
Definition: type_traits_generator.h:1001
is_signed
Definition: type_traits_generator.h:1011
is_unsigned
Definition: type_traits_generator.h:1021
bitset_ext
Definition: absolute.h:38
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, T >::type rotr(T value, int n) ETL_NOEXCEPT
rotr
Definition: bit.h:228
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, int >::type countl_one(T value) ETL_NOEXCEPT
countl_one
Definition: bit.h:117
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, T >::type rotl(T value, int n) ETL_NOEXCEPT
rotl
Definition: bit.h:210
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value, T >::type byteswap(T value) ETL_NOEXCEPT
byteswap
Definition: bit.h:86
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, int >::type popcount(T value) ETL_NOEXCEPT
popcount
Definition: bit.h:246
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, int >::type countr_one(T value) ETL_NOEXCEPT
countr_one
Definition: bit.h:139
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, int >::type countr_zero(T value) ETL_NOEXCEPT
countr_zero
Definition: bit.h:128
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, int >::type countl_zero(T value) ETL_NOEXCEPT
countl_zero
Definition: bit.h:106