Embedded Template Library 1.0
Loading...
Searching...
No Matches
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 //***************************************************************************
68
69 //***************************************************************************
72 //***************************************************************************
74 {
75 public:
76
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
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
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
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
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.
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 <size_t POSITION>
352 struct bit
353 {
354 typedef typename etl::smallest_uint_for_bits<POSITION + 1U>::type value_type;
355 static ETL_CONSTANT value_type value = value_type(1) << POSITION;
356 };
357
358 template <size_t POSITION>
359 ETL_CONSTANT typename bit<POSITION>::value_type bit<POSITION>::value;
360
361#if ETL_USING_CPP11
362 template <size_t POSITION>
363 using bit_t = typename etl::bit<POSITION>::value_type;
364#endif
365
366#if ETL_USING_CPP17
367 template <size_t POSITION>
369#endif
370
371 //***************************************************************************
374 //***************************************************************************
375 template <typename TResult, typename TValue>
376 ETL_CONSTEXPR TResult binary_fill(TValue value)
377 {
378 ETL_STATIC_ASSERT(sizeof(TResult) >= sizeof(TValue), "Result must be at least as large as the fill value");
379
382
384 }
385
386 //***************************************************************************
389 //***************************************************************************
390 template <typename TResult, typename TValue, TValue N>
391 ETL_CONSTEXPR TResult binary_fill()
392 {
393 ETL_STATIC_ASSERT(sizeof(TResult) >= sizeof(TValue), "Result must be at least as large as the fill value");
394
397
399 }
400
401#if ETL_USING_8BIT_TYPES
402 //***************************************************************************
405 //***************************************************************************
406 template <typename TValue>
407 ETL_CONSTEXPR14 bool has_zero_byte(TValue value)
408 {
409 typedef typename etl::make_unsigned<TValue>::type unsigned_t;
410 ETL_CONSTEXPR14 const unsigned_t mask = etl::binary_fill<unsigned_t, uint8_t>(0x7FU);
411 const unsigned_t temp = unsigned_t(~((((unsigned_t(value) & mask) + mask) | unsigned_t(value)) | mask));
412
413 return (temp != 0U);
414 }
415
416 //***************************************************************************
419 //***************************************************************************
420 template <typename TValue, TValue N>
421 ETL_CONSTEXPR14 bool has_zero_byte()
422 {
423 typedef typename etl::make_unsigned<TValue>::type unsigned_t;
424 ETL_CONSTEXPR14 const unsigned_t mask = etl::binary_fill<unsigned_t, uint8_t>(0x7FU);
425 const unsigned_t temp = unsigned_t(~((((unsigned_t(N) & mask) + mask) | unsigned_t(N)) | mask));
426
427 return (temp != 0U);
428 }
429
430 //***************************************************************************
433 //***************************************************************************
434 template <typename TValue>
435 ETL_CONSTEXPR14 bool has_byte_n(TValue value, uint8_t n)
436 {
437 return etl::has_zero_byte(TValue(value ^ etl::binary_fill<TValue, uint8_t>(n)));
438 }
439
440 //***************************************************************************
443 //***************************************************************************
444 template <typename TValue, TValue N>
445 ETL_CONSTEXPR14 bool has_byte_n(TValue value)
446 {
447 return etl::has_zero_byte(TValue(value ^ etl::binary_fill<TValue, uint8_t>(N)));
448 }
449#endif
450
451 //***************************************************************************
456 //***************************************************************************
457 template <typename T>
458 ETL_CONSTEXPR T binary_merge(T first, T second, T mask)
459 {
460 return second ^ ((second ^ first) & mask);
461 }
462
463 //***************************************************************************
468 //***************************************************************************
469 template <typename T, T MASK>
470 ETL_CONSTEXPR T binary_merge(T first, T second)
471 {
472 return second ^ ((second ^ first) & MASK);
473 }
474
475 //***************************************************************************
478 //***************************************************************************
479 template <typename T, T Value>
481
482#if ETL_USING_8BIT_TYPES
483 //***************************************************************************
486 //***************************************************************************
487 template <typename T>
488 ETL_CONSTEXPR14
490 reverse_bits(T value)
491 {
492 value = ((value & 0xAAU) >> 1U) | ((value & 0x55U) << 1U);
493 value = ((value & 0xCCU) >> 2U) | ((value & 0x33U) << 2U);
494 value = (value >> 4U) | ((value & 0x0FU) << 4U);
495
496 return value;
497 }
498
499 //***********************************
500 template <uint8_t Value>
502 {
503 private:
504
505 static ETL_CONSTANT uint8_t value1 = uint8_t(((Value & 0xAAU) >> 1U) | ((Value & 0x55U) << 1U));
506 static ETL_CONSTANT uint8_t value2 = uint8_t(((value1 & 0xCCU) >> 2U) | ((value1 & 0x33U) << 2U));
507
508 public:
509
510 static ETL_CONSTANT uint8_t value = uint8_t((value2 >> 4U) | ((value2 & 0x0FU) << 4U));
511 };
512
513 template <uint8_t Value>
514 ETL_CONSTANT uint8_t reverse_bits_const<uint8_t, Value>::value;
515
516 //***********************************
517 template <int8_t Value>
518 struct reverse_bits_const<int8_t, Value>
519 {
520 private:
521
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));
524
525 public:
526
527 static ETL_CONSTANT int8_t value = int8_t((value2 >> 4U) | ((value2 & 0x0FU) << 4U));
528 };
529
530 template <int8_t Value>
531 ETL_CONSTANT int8_t reverse_bits_const<int8_t, Value>::value;
532#endif
533
534 //***************************************************************************
537 //***************************************************************************
538 template <typename T>
539 ETL_CONSTEXPR14
542 {
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);
547
548 return value;
549 }
550
551 //***********************************
552 template <uint16_t Value>
554 {
555 private:
556
557 static ETL_CONSTANT uint16_t value1 = uint16_t(((Value & 0xAAAAU) >> 1U) | ((Value & 0x5555U) << 1U));
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));
560
561 public:
562
563 static ETL_CONSTANT uint16_t value = uint16_t((value3 >> 8U) | ((value3 & 0xFFU) << 8U));
564 };
565
566 template <uint16_t Value>
568
569 //***********************************
570 template <int16_t Value>
572 {
573 private:
574
575 static ETL_CONSTANT int16_t value1 = int16_t(((Value & 0xAAAAU) >> 1U) | ((Value & 0x5555U) << 1U));
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));
578
579 public:
580
581 static ETL_CONSTANT int16_t value = int16_t((value3 >> 8U) | ((value3 & 0xFFU) << 8U));
582 };
583
584 template <int16_t Value>
586
587 //***************************************************************************
590 //***************************************************************************
591 template <typename T>
592 ETL_CONSTEXPR14
595 {
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);
601
602 return value;
603 }
604
605 //***********************************
606 template <uint32_t Value>
608 {
609 private:
610
611 static ETL_CONSTANT uint32_t value1 = uint32_t(((Value & 0xAAAAAAAAUL) >> 1U) | ((Value & 0x55555555UL) << 1U));
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));
615
616 public:
617
618 static ETL_CONSTANT uint32_t value = uint32_t((value4 >> 16U) | ((value4 & 0xFFFFU) << 16U));
619 };
620
621 template <uint32_t Value>
623
624 //***********************************
625 template <int32_t Value>
627 {
628 private:
629
630 static ETL_CONSTANT int32_t value1 = int32_t(((Value & 0xAAAAAAAAUL) >> 1U) | ((Value & 0x55555555UL) << 1U));
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));
634
635 public:
636
637 static ETL_CONSTANT int32_t value = int32_t((value4 >> 16U) | ((value4 & 0xFFFFUL) << 16U));
638 };
639
640 template <int32_t Value>
642
643#if ETL_USING_64BIT_TYPES
644 //***************************************************************************
647 //***************************************************************************
648 template <typename T>
649 ETL_CONSTEXPR14
652 {
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);
659
660 return value;
661 }
662
663 //***********************************
664 template <uint64_t Value>
666 {
667 private:
668
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));
674
675 public:
676
677 static ETL_CONSTANT uint64_t value = uint64_t((value5 >> 32U) | ((value5 & 0xFFFFFFFFULL) << 32U));
678 };
679
680 template <uint64_t Value>
682
683 //***********************************
684 template <int64_t Value>
686 {
687 private:
688
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));
694
695 public:
696
697 static ETL_CONSTANT int64_t value = int64_t((value5 >> 32U) | ((value5 & 0xFFFFFFFFULL) << 32U));
698 };
699
700 template <int64_t Value>
702#endif
703
704 //***************************************************************************
707 //***************************************************************************
708 template <typename T>
709 ETL_CONSTEXPR14
712 {
714
715 return static_cast<T>(reverse_bits(static_cast<unsigned_t>(value)));
716 }
717
718 //***************************************************************************
721 //***************************************************************************
722#if ETL_USING_8BIT_TYPES
723 template <typename T>
724 ETL_CONSTEXPR14
726 reverse_bytes(T value)
727 {
728 return value;
729 }
730#endif
731
732 //***************************************************************************
735 //***************************************************************************
736 template <typename T>
737 ETL_CONSTEXPR14
740 {
741#if ETL_CPP23_SUPPORTED && ETL_USING_STL
742 return std::byteswap(value);
743#else
744 return (value >> 8U) | (value << 8U);
745#endif
746 }
747
748 //***************************************************************************
751 //***************************************************************************
752 template <typename T>
753 ETL_CONSTEXPR14
756 {
757#if ETL_CPP23_SUPPORTED && ETL_USING_STL
758 return std::byteswap(value);
759#else
760 value = ((value & 0xFF00FF00UL) >> 8U) | ((value & 0x00FF00FFUL) << 8U);
761 value = (value >> 16U) | (value << 16U);
762
763 return value;
764#endif
765 }
766
767#if ETL_USING_64BIT_TYPES
768 //***************************************************************************
771 //***************************************************************************
772 template <typename T>
773 ETL_CONSTEXPR14
776 {
777#if ETL_CPP23_SUPPORTED && ETL_USING_STL
778 return std::byteswap(value);
779#else
780 value = ((value & 0xFF00FF00FF00FF00ULL) >> 8U) | ((value & 0x00FF00FF00FF00FFULL) << 8U);
781 value = ((value & 0xFFFF0000FFFF0000ULL) >> 16U) | ((value & 0x0000FFFF0000FFFFULL) << 16U);
782 value = (value >> 32U) | (value << 32U);
783
784 return value;
785#endif
786 }
787#endif
788
789 //***************************************************************************
792 //***************************************************************************
793 template <typename T>
794 ETL_CONSTEXPR14
797 {
799
800 return static_cast<T>(reverse_bytes(static_cast<unsigned_t>(value)));
801 }
802
803#if ETL_USING_8BIT_TYPES
804 //***************************************************************************
807 //***************************************************************************
808 template <typename T>
809 ETL_CONSTEXPR14
811 gray_to_binary(T value)
812 {
813 value ^= (value >> 4U);
814 value ^= (value >> 2U);
815 value ^= (value >> 1U);
816
817 return value;
818 }
819#endif
820
821 //***************************************************************************
824 //***************************************************************************
825 template <typename T>
826 ETL_CONSTEXPR14
829 {
830 value ^= (value >> 8U);
831 value ^= (value >> 4U);
832 value ^= (value >> 2U);
833 value ^= (value >> 1U);
834
835 return value;
836 }
837
838 //***************************************************************************
841 //***************************************************************************
842 template <typename T>
843 ETL_CONSTEXPR14
846 {
847 value ^= (value >> 16U);
848 value ^= (value >> 8U);
849 value ^= (value >> 4U);
850 value ^= (value >> 2U);
851 value ^= (value >> 1U);
852
853 return value;
854 }
855
856#if ETL_USING_64BIT_TYPES
857 //***************************************************************************
860 //***************************************************************************
861 template <typename T>
862 ETL_CONSTEXPR14
865 {
866 value ^= (value >> 32U);
867 value ^= (value >> 16U);
868 value ^= (value >> 8U);
869 value ^= (value >> 4U);
870 value ^= (value >> 2U);
871 value ^= (value >> 1U);
872
873 return value;
874 }
875#endif
876
877 //***************************************************************************
880 //***************************************************************************
881 template <typename T>
882 ETL_CONSTEXPR14
885 {
887
888 return static_cast<T>(gray_to_binary(static_cast<unsigned_t>(value)));
889 }
890
891#if ETL_USING_8BIT_TYPES
892 //***************************************************************************
895 //***************************************************************************
896 template <typename T>
897 ETL_CONSTEXPR14
899 count_bits(T value)
900 {
901#if ETL_CPP23_SUPPORTED && ETL_USING_STL
902 return std::popcount(value);
903#else
904 uint32_t count = 0U;
905
906 count = value - ((value >> 1U) & 0x55U);
907 count = ((count >> 2U) & 0x33U) + (count & 0x33U);
908 count = ((count >> 4U) + count) & 0x0FU;
909
910 return uint_least8_t(count);
911#endif
912 }
913#endif
914
915 //***************************************************************************
918 //***************************************************************************
919 template <typename T>
920 ETL_CONSTEXPR14
923 {
924#if ETL_USING_CPP20 && ETL_USING_STL
925 return std::popcount(value);
926#else
927 uint32_t count = 0U;
928
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;
933
934 return static_cast<uint_least8_t>(count);
935#endif
936 }
937
938 //***************************************************************************
941 //***************************************************************************
942 template <typename T>
943 ETL_CONSTEXPR14
946 {
947#if ETL_USING_CPP20 && ETL_USING_STL
948 return std::popcount(value);
949#else
950 uint32_t count = 0U;
951
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;
957
958 return static_cast<uint_least8_t>(count);
959#endif
960 }
961
962#if ETL_USING_64BIT_TYPES
963 //***************************************************************************
966 //***************************************************************************
967 template <typename T>
968 ETL_CONSTEXPR14
971 {
972#if ETL_USING_CPP20 && ETL_USING_STL
973 return std::popcount(value);
974#else
975 uint64_t count = 0U;
976
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;
983
984 return static_cast<uint_least8_t>(count);
985#endif
986 }
987#endif
988
989 //***************************************************************************
992 //***************************************************************************
993 template <typename T>
994 ETL_CONSTEXPR14
997 {
999
1000 return static_cast<T>(count_bits(static_cast<unsigned_t>(value)));
1001 }
1002
1003#if ETL_USING_8BIT_TYPES
1004 //***************************************************************************
1007 //***************************************************************************
1008 template <typename T>
1009 ETL_CONSTEXPR14
1011 parity(T value)
1012 {
1013 value ^= value >> 4U;
1014 value &= 0x0FU;
1015 return (0x6996U >> value) & 1U;
1016 }
1017#endif
1018
1019 //***************************************************************************
1022 //***************************************************************************
1023 template <typename T>
1024 ETL_CONSTEXPR14
1026 parity(T value)
1027 {
1028 value ^= value >> 8U;
1029 value ^= value >> 4U;
1030 value &= 0x0FU;
1031 return (0x6996U >> value) & 1U;
1032 }
1033
1034 //***************************************************************************
1037 //***************************************************************************
1038 template <typename T>
1039 ETL_CONSTEXPR14
1041 parity(T value)
1042 {
1043 value ^= value >> 16U;
1044 value ^= value >> 8U;
1045 value ^= value >> 4U;
1046 value &= 0x0FU;
1047 return (0x6996U >> value) & 1U;
1048 }
1049
1050#if ETL_USING_64BIT_TYPES
1051 //***************************************************************************
1054 //***************************************************************************
1055 template <typename T>
1056 ETL_CONSTEXPR14
1058 parity(T value)
1059 {
1060 value ^= value >> 32U;
1061 value ^= value >> 16U;
1062 value ^= value >> 8U;
1063 value ^= value >> 4U;
1064 value &= 0x0FU;
1065 return (0x69966996UL >> value) & 1U;
1066 }
1067#endif
1068
1069 //***************************************************************************
1072 //***************************************************************************
1073 template <typename T>
1074 ETL_CONSTEXPR14
1076 parity(T value)
1077 {
1078 typedef typename etl::make_unsigned<T>::type unsigned_t;
1079
1080 return static_cast<T>(parity(static_cast<unsigned_t>(value)));
1081 }
1082
1083#if ETL_USING_8BIT_TYPES
1084 //***************************************************************************
1088 //***************************************************************************
1089 template <typename T>
1090 ETL_CONSTEXPR14
1092 count_trailing_zeros(T value)
1093 {
1094#if ETL_USING_CPP20 && ETL_USING_STL
1095 return std::countr_zero(value);
1096#else
1097 uint_least8_t count = 0U;
1098
1099 if (value & 0x1U)
1100 {
1101 count = 0U;
1102 }
1103 else
1104 {
1105 count = 1U;
1106
1107 if ((value & 0xFU) == 0U)
1108 {
1109 value >>= 4U;
1110 count += 4U;
1111 }
1112
1113 if ((value & 0x3U) == 0U)
1114 {
1115 value >>= 2U;
1116 count += 2U;
1117 }
1118
1119 if ((value & 0x1U) == 0U)
1120 {
1121 value >>= 1U;
1122 count += 1U;
1123 }
1124
1125 count -= (value & 0x1U);
1126 }
1127
1128 return count;
1129#endif
1130 }
1131#endif
1132
1133 //***************************************************************************
1137 //***************************************************************************
1138 template <typename T>
1139 ETL_CONSTEXPR14
1142 {
1143#if ETL_USING_CPP20 && ETL_USING_STL
1144 return std::countr_zero(value);
1145#else
1146 uint_least8_t count = 0U;
1147
1148 if (value & 0x1U)
1149 {
1150 count = 0U;
1151 }
1152 else
1153 {
1154 count = 1U;
1155
1156 if ((value & 0xFFU) == 0U)
1157 {
1158 value >>= 8U;
1159 count += 8U;
1160 }
1161
1162 if ((value & 0xFU) == 0U)
1163 {
1164 value >>= 4U;
1165 count += 4U;
1166 }
1167
1168 if ((value & 0x3U) == 0U)
1169 {
1170 value >>= 2U;
1171 count += 2U;
1172 }
1173
1174 if ((value & 0x1U) == 0U)
1175 {
1176 value >>= 1U;
1177 count += 1U;
1178 }
1179
1180 count -= value & 0x1U;
1181 }
1182
1183 return count;
1184#endif
1185 }
1186
1187 //***************************************************************************
1191 //***************************************************************************
1192 template <typename T>
1193 ETL_CONSTEXPR14
1196 {
1197#if ETL_USING_CPP20 && ETL_USING_STL
1198 return std::countr_zero(value);
1199#else
1200 uint_least8_t count = 0U;
1201
1202 if (value & 0x1UL)
1203 {
1204 count = 0U;
1205 }
1206 else
1207 {
1208 count = 1U;
1209
1210 if ((value & 0xFFFFUL) == 0UL)
1211 {
1212 value >>= 16U;
1213 count += 16U;
1214 }
1215
1216 if ((value & 0xFFUL) == 0UL)
1217 {
1218 value >>= 8U;
1219 count += 8U;
1220 }
1221
1222 if ((value & 0xFUL) == 0UL)
1223 {
1224 value >>= 4U;
1225 count += 4U;
1226 }
1227
1228 if ((value & 0x3UL) == 0UL)
1229 {
1230 value >>= 2U;
1231 count += 2U;
1232 }
1233
1234 if ((value & 0x1U) == 0U)
1235 {
1236 value >>= 1U;
1237 count += 1U;
1238 }
1239
1240 count -= value & 0x1UL;
1241 }
1242
1243 return count;
1244#endif
1245 }
1246
1247#if ETL_USING_64BIT_TYPES
1248 //***************************************************************************
1252 //***************************************************************************
1253 template <typename T>
1254 ETL_CONSTEXPR14
1257 {
1258#if ETL_USING_CPP20 && ETL_USING_STL
1259 return std::countr_zero(value);
1260#else
1261 uint_least8_t count = 0U;
1262
1263 if (value & 0x1ULL)
1264 {
1265 count = 0U;
1266 }
1267 else
1268 {
1269 count = 1U;
1270
1271 if ((value & 0xFFFFFFFFULL) == 0ULL)
1272 {
1273 value >>= 32U;
1274 count += 32U;
1275 }
1276
1277 if ((value & 0xFFFFULL) == 0ULL)
1278 {
1279 value >>= 16U;
1280 count += 16U;
1281 }
1282
1283 if ((value & 0xFFULL) == 0ULL)
1284 {
1285 value >>= 8U;
1286 count += 8U;
1287 }
1288
1289 if ((value & 0xFULL) == 0ULL)
1290 {
1291 value >>= 4U;
1292 count += 4U;
1293 }
1294
1295 if ((value & 0x3ULL) == 0ULL)
1296 {
1297 value >>= 2U;
1298 count += 2U;
1299 }
1300
1301 if ((value & 0x1U) == 0U)
1302 {
1303 value >>= 1U;
1304 count += 1U;
1305 }
1306
1307 count -= value & 0x1ULL;
1308 }
1309
1310 return count;
1311#endif
1312 }
1313#endif
1314
1315 //***************************************************************************
1318 //***************************************************************************
1319 template <typename T>
1320 ETL_CONSTEXPR14
1323 {
1324 typedef typename etl::make_unsigned<T>::type unsigned_t;
1325
1326 return static_cast<T>(count_trailing_zeros(static_cast<unsigned_t>(value)));
1327 }
1328
1329#if ETL_USING_8BIT_TYPES
1330 //***************************************************************************
1334 //***************************************************************************
1335 template <typename T>
1336 ETL_CONSTEXPR14
1338 count_trailing_ones(T value)
1339 {
1340#if ETL_USING_CPP20 && ETL_USING_STL
1341 return std::countr_one(value);
1342#else
1343 uint_least8_t count = 0U;
1344
1345 if ((value & 0x1U) == 0x0U)
1346 {
1347 count = 0U;
1348 }
1349 else
1350 {
1351 count = 1U;
1352
1353 if ((value & 0xFU) == 0xFU)
1354 {
1355 value >>= 4U;
1356 count += 4U;
1357 }
1358
1359 if ((value & 0x3U) == 0x3U)
1360 {
1361 value >>= 2U;
1362 count += 2U;
1363 }
1364
1365 if ((value & 0x1U) == 0x1U)
1366 {
1367 value >>= 1U;
1368 count += 1U;
1369 }
1370
1371 count -= ((value & 0x1U) == 0x0U);
1372 }
1373
1374 return count;
1375#endif
1376 }
1377#endif
1378
1379 //***************************************************************************
1383 //***************************************************************************
1384 template <typename T>
1385 ETL_CONSTEXPR14
1388 {
1389#if ETL_USING_CPP20 && ETL_USING_STL
1390 return std::countr_one(value);
1391#else
1392 uint_least8_t count = 0U;
1393
1394 if ((value & 0x1U) == 0x0U)
1395 {
1396 count = 0U;
1397 }
1398 else
1399 {
1400 count = 1U;
1401
1402 if ((value & 0xFFU) == 0xFFU)
1403 {
1404 value >>= 8U;
1405 count += 8U;
1406 }
1407
1408 if ((value & 0xFU) == 0xFU)
1409 {
1410 value >>= 4U;
1411 count += 4U;
1412 }
1413
1414 if ((value & 0x3U) == 0x3U)
1415 {
1416 value >>= 2U;
1417 count += 2U;
1418 }
1419
1420 if ((value & 0x1U) == 0x1U)
1421 {
1422 value >>= 1U;
1423 count += 1U;
1424 }
1425
1426 count -= ((value & 0x1U) == 0x0U);
1427 }
1428
1429 return count;
1430#endif
1431 }
1432
1433 //***************************************************************************
1437 //***************************************************************************
1438 template <typename T>
1439 ETL_CONSTEXPR14
1442 {
1443#if ETL_USING_CPP20 && ETL_USING_STL
1444 return std::countr_one(value);
1445#else
1446 uint_least8_t count = 0U;
1447
1448 if ((value & 0x1UL) == 0x0UL)
1449 {
1450 count = 0U;
1451 }
1452 else
1453 {
1454 count = 1U;
1455
1456 if ((value & 0xFFFFUL) == 0xFFFFUL)
1457 {
1458 value >>= 16U;
1459 count += 16U;
1460 }
1461
1462 if ((value & 0xFFUL) == 0xFFUL)
1463 {
1464 value >>= 8U;
1465 count += 8U;
1466 }
1467
1468 if ((value & 0xFUL) == 0xFUL)
1469 {
1470 value >>= 4U;
1471 count += 4U;
1472 }
1473
1474 if ((value & 0x3UL) == 0x3UL)
1475 {
1476 value >>= 2U;
1477 count += 2U;
1478 }
1479
1480 if ((value & 0x1UL) == 0x1UL)
1481 {
1482 value >>= 1U;
1483 count += 1U;
1484 }
1485
1486 count -= ((value & 0x1UL) == 0x0UL);
1487 }
1488
1489 return count;
1490#endif
1491 }
1492
1493#if ETL_USING_64BIT_TYPES
1494 //***************************************************************************
1498 //***************************************************************************
1499 template <typename T>
1500 ETL_CONSTEXPR14
1503 {
1504#if ETL_USING_CPP20 && ETL_USING_STL
1505 return std::countr_one(value);
1506#else
1507 uint_least8_t count = 0U;
1508
1509 if ((value & 0x1ULL) == 0x0ULL)
1510 {
1511 count = 0U;
1512 }
1513 else
1514 {
1515 count = 1U;
1516
1517 if ((value & 0xFFFFULL) == 0xFFFFULL)
1518 {
1519 value >>= 16U;
1520 count += 16U;
1521 }
1522
1523 if ((value & 0xFFULL) == 0xFFULL)
1524 {
1525 value >>= 8U;
1526 count += 8U;
1527 }
1528
1529 if ((value & 0xFULL) == 0xFULL)
1530 {
1531 value >>= 4U;
1532 count += 4U;
1533 }
1534
1535 if ((value & 0x3ULL) == 0x3ULL)
1536 {
1537 value >>= 2U;
1538 count += 2U;
1539 }
1540
1541 if ((value & 0x1ULL) == 0x1ULL)
1542 {
1543 value >>= 1U;
1544 count += 1U;
1545 }
1546
1547 count -= ((value & 0x1ULL) == 0x0ULL);
1548 }
1549
1550 return count;
1551#endif
1552 }
1553#endif
1554
1555 //***************************************************************************
1558 //***************************************************************************
1559 template <typename T>
1560 ETL_CONSTEXPR14
1563 {
1564 typedef typename etl::make_unsigned<T>::type unsigned_t;
1565
1566 return static_cast<T>(count_trailing_ones(static_cast<unsigned_t>(value)));
1567 }
1568
1569#if ETL_USING_8BIT_TYPES
1570 //***************************************************************************
1574 //***************************************************************************
1575 template <typename T>
1576 ETL_CONSTEXPR14
1578 count_leading_zeros(T value)
1579 {
1580#if ETL_USING_CPP20 && ETL_USING_STL
1581 return std::countl_zero(value);
1582#else
1583 uint_least8_t count = 0U;
1584
1585 if (value & 0x80U)
1586 {
1587 count = 0U;
1588 }
1589 else
1590 {
1591 count = 1U;
1592
1593 if ((value & 0xF0U) == 0U)
1594 {
1595 value <<= 4U;
1596 count += 4U;
1597 }
1598
1599 if ((value & 0xC0U) == 0U)
1600 {
1601 value <<= 2U;
1602 count += 2U;
1603 }
1604
1605 if ((value & 0x80U) == 0U)
1606 {
1607 value <<= 1U;
1608 count += 1U;
1609 }
1610
1611 count -= ((value & 0x80U) == 0x80U);
1612 }
1613
1614 return count;
1615#endif
1616 }
1617#endif
1618
1619 //***************************************************************************
1623 //***************************************************************************
1624 template <typename T>
1625 ETL_CONSTEXPR14
1628 {
1629#if ETL_USING_CPP20 && ETL_USING_STL
1630 return std::countl_zero(value);
1631#else
1632 uint_least8_t count = 0U;
1633
1634 if (value & 0x8000U)
1635 {
1636 count = 0U;
1637 }
1638 else
1639 {
1640 count = 1U;
1641
1642 if ((value & 0xFF00U) == 0U)
1643 {
1644 value <<= 8U;
1645 count += 8U;
1646 }
1647
1648 if ((value & 0xF000U) == 0U)
1649 {
1650 value <<= 4U;
1651 count += 4U;
1652 }
1653
1654 if ((value & 0xC000U) == 0U)
1655 {
1656 value <<= 2U;
1657 count += 2U;
1658 }
1659
1660 if ((value & 0x8000U) == 0U)
1661 {
1662 value <<= 1U;
1663 count += 1U;
1664 }
1665
1666 count -= ((value & 0x8000U) == 0x8000U);
1667 }
1668
1669 return count;
1670#endif
1671 }
1672
1673 //***************************************************************************
1677 //***************************************************************************
1678 template <typename T>
1679 ETL_CONSTEXPR14
1682 {
1683#if ETL_USING_CPP20 && ETL_USING_STL
1684 return std::countl_zero(value);
1685#else
1686 uint_least8_t count = 0U;
1687
1688 if (value & 0x80000000UL)
1689 {
1690 count = 0U;
1691 }
1692 else
1693 {
1694 count = 1U;
1695
1696 if ((value & 0xFFFF0000UL) == 0U)
1697 {
1698 value <<= 16U;
1699 count += 16U;
1700 }
1701
1702 if ((value & 0xFF000000UL) == 0U)
1703 {
1704 value <<= 8U;
1705 count += 8U;
1706 }
1707
1708 if ((value & 0xF0000000UL) == 0U)
1709 {
1710 value <<= 4U;
1711 count += 4U;
1712 }
1713
1714 if ((value & 0xC0000000UL) == 0U)
1715 {
1716 value <<= 2U;
1717 count += 2U;
1718 }
1719
1720 if ((value & 0x80000000UL) == 0U)
1721 {
1722 value <<= 1U;
1723 count += 1U;
1724 }
1725
1726 count -= ((value & 0x80000000UL) == 0x80000000UL);
1727 }
1728
1729 return count;
1730#endif
1731 }
1732
1733#if ETL_USING_64BIT_TYPES
1734 //***************************************************************************
1738 //***************************************************************************
1739 template <typename T>
1740 ETL_CONSTEXPR14
1743 {
1744#if ETL_USING_CPP20 && ETL_USING_STL
1745 return std::countl_zero(value);
1746#else
1747 uint_least8_t count = 0U;
1748
1749 if (value & 0x8000000000000000ULL)
1750 {
1751 count = 0U;
1752 }
1753 else
1754 {
1755 count = 1U;
1756
1757 if ((value & 0xFFFFFFFFF0000000ULL) == 0U)
1758 {
1759 value <<= 32U;
1760 count += 32U;
1761 }
1762
1763 if ((value & 0xFFFF000000000000ULL) == 0U)
1764 {
1765 value <<= 16U;
1766 count += 16U;
1767 }
1768
1769 if ((value & 0xFF00000000000000ULL) == 0U)
1770 {
1771 value <<= 8U;
1772 count += 8U;
1773 }
1774
1775 if ((value & 0xF000000000000000ULL) == 0U)
1776 {
1777 value <<= 4U;
1778 count += 4U;
1779 }
1780
1781 if ((value & 0xC000000000000000ULL) == 0U)
1782 {
1783 value <<= 2U;
1784 count += 2U;
1785 }
1786
1787 if ((value & 0x8000000000000000ULL) == 0U)
1788 {
1789 value <<= 1U;
1790 count += 1U;
1791 }
1792
1793 count -= ((value & 0x8000000000000000ULL) == 0x8000000000000000ULL);
1794 }
1795
1796 return count;
1797#endif
1798 }
1799#endif
1800
1801 //***************************************************************************
1804 //***************************************************************************
1805 template <typename T>
1806 ETL_CONSTEXPR14
1809 {
1810 typedef typename etl::make_unsigned<T>::type unsigned_t;
1811
1812 return static_cast<T>(count_trailing_ones(static_cast<unsigned_t>(value)));
1813 }
1814
1815#if ETL_USING_8BIT_TYPES
1816 //***************************************************************************
1820 //***************************************************************************
1821 template <typename T>
1822 ETL_CONSTEXPR14
1824 count_leading_ones(T value)
1825 {
1826#if ETL_USING_CPP20 && ETL_USING_STL
1827 return std::countl_one(value);
1828#else
1829 uint_least8_t count = 0U;
1830
1831 if ((value & 0x80U) == 0U)
1832 {
1833 count = 0U;
1834 }
1835 else
1836 {
1837 count = 1U;
1838
1839 if ((value & 0xF0U) == 0xF0U)
1840 {
1841 value <<= 4U;
1842 count += 4U;
1843 }
1844
1845 if ((value & 0xC0U) == 0xC0U)
1846 {
1847 value <<= 2U;
1848 count += 2U;
1849 }
1850
1851 if ((value & 0x80U) == 0x80U)
1852 {
1853 value <<= 1U;
1854 count += 1U;
1855 }
1856
1857 count -= ((value & 0x80U) == 0x0U);
1858 }
1859
1860 return count;
1861#endif
1862 }
1863#endif
1864
1865 //***************************************************************************
1869 //***************************************************************************
1870 template <typename T>
1871 ETL_CONSTEXPR14
1874 {
1875#if ETL_USING_CPP20 && ETL_USING_STL
1876 return std::countl_one(value);
1877#else
1878 uint_least8_t count = 0U;
1879
1880 if ((value & 0x8000U) == 0U)
1881 {
1882 count = 0U;
1883 }
1884 else
1885 {
1886 count = 1U;
1887
1888 if ((value & 0xFF00U) == 0xFF00U)
1889 {
1890 value <<= 8U;
1891 count += 8U;
1892 }
1893
1894 if ((value & 0xF000U) == 0xF000U)
1895 {
1896 value <<= 4U;
1897 count += 4U;
1898 }
1899
1900 if ((value & 0xC000U) == 0xC000U)
1901 {
1902 value <<= 2U;
1903 count += 2U;
1904 }
1905
1906 if ((value & 0x8000U) == 0x8000U)
1907 {
1908 value <<= 1U;
1909 count += 1U;
1910 }
1911
1912 count -= ((value & 0x8000U) == 0U);
1913 }
1914
1915 return count;
1916#endif
1917 }
1918
1919 //***************************************************************************
1923 //***************************************************************************
1924 template <typename T>
1925 ETL_CONSTEXPR14
1928 {
1929#if ETL_USING_CPP20 && ETL_USING_STL
1930 return std::countl_one(value);
1931#else
1932 uint_least8_t count = 0U;
1933
1934 if ((value & 0x80000000UL) == 0UL)
1935 {
1936 count = 0U;
1937 }
1938 else
1939 {
1940 count = 1U;
1941
1942 if ((value & 0xFFFF0000UL) == 0xFFFF0000UL)
1943 {
1944 value <<= 8U;
1945 count += 8U;
1946 }
1947
1948 if ((value & 0xFF000000UL) == 0xFF000000UL)
1949 {
1950 value <<= 8U;
1951 count += 8U;
1952 }
1953
1954 if ((value & 0xF0000000UL) == 0xF0000000UL)
1955 {
1956 value <<= 4U;
1957 count += 4U;
1958 }
1959
1960 if ((value & 0xC0000000UL) == 0xC0000000UL)
1961 {
1962 value <<= 2U;
1963 count += 2U;
1964 }
1965
1966 if ((value & 0x80000000UL) == 0x80000000UL)
1967 {
1968 value <<= 1U;
1969 count += 1U;
1970 }
1971
1972 count -= ((value & 0x80000000UL) == 0UL);
1973 }
1974
1975 return count;
1976#endif
1977 }
1978
1979#if ETL_USING_64BIT_TYPES
1980 //***************************************************************************
1984 //***************************************************************************
1985 template <typename T>
1986 ETL_CONSTEXPR14
1989 {
1990#if ETL_USING_CPP20 && ETL_USING_STL
1991 return std::countl_one(value);
1992#else
1993 uint_least8_t count = 0U;
1994
1995 if ((value & 0x8000000000000000ULL) == 0ULL)
1996 {
1997 count = 0U;
1998 }
1999 else
2000 {
2001 count = 1U;
2002
2003 if ((value & 0xFFFFFFFF00000000ULL) == 0xFFFFFFFF00000000ULL)
2004 {
2005 value <<= 8U;
2006 count += 8U;
2007 }
2008
2009 if ((value & 0xFFFF000000000000ULL) == 0xFFFF000000000000ULL)
2010 {
2011 value <<= 8U;
2012 count += 8U;
2013 }
2014
2015 if ((value & 0xFF00000000000000ULL) == 0xFF00000000000000ULL)
2016 {
2017 value <<= 8U;
2018 count += 8U;
2019 }
2020
2021 if ((value & 0xF000000000000000ULL) == 0xF000000000000000ULL)
2022 {
2023 value <<= 4U;
2024 count += 4U;
2025 }
2026
2027 if ((value & 0xC000000000000000ULL) == 0xC000000000000000ULL)
2028 {
2029 value <<= 2U;
2030 count += 2U;
2031 }
2032
2033 if ((value & 0x8000000000000000ULL) == 0x8000000000000000ULL)
2034 {
2035 value <<= 1U;
2036 count += 1U;
2037 }
2038
2039 count -= ((value & 0x8000000000000000ULL) == 0ULL);
2040 }
2041
2042 return count;
2043#endif
2044 }
2045#endif
2046
2047 //***************************************************************************
2050 //***************************************************************************
2051 template <typename T>
2052 ETL_CONSTEXPR14
2055 {
2056 typedef typename etl::make_unsigned<T>::type unsigned_t;
2057
2058 return static_cast<T>(count_leading_ones(static_cast<unsigned_t>(value)));
2059 }
2060
2061 //***************************************************************************
2065 //***************************************************************************
2066 template <typename T>
2068 {
2069 return count_trailing_zeros(value);
2070 }
2071
2072 //***************************************************************************
2076 //***************************************************************************
2077 template <typename T>
2079 {
2080 value = ~value;
2081 return count_trailing_zeros(value);
2082 }
2083
2084 //***************************************************************************
2088 //***************************************************************************
2089 template <typename T>
2090 ETL_CONSTEXPR14 uint_least8_t first_bit_position(bool state, T value)
2091 {
2092 if (!state)
2093 {
2094 value = ~value;
2095 }
2096
2097 return count_trailing_zeros(value);
2098 }
2099
2100#if ETL_USING_8BIT_TYPES
2101 //*****************************************************************************
2104 //*****************************************************************************
2105 template <typename T>
2106 ETL_CONSTEXPR14
2108 binary_interleave(T first, T second)
2109 {
2110 uint16_t f = uint16_t(first);
2111 uint16_t s = uint16_t(second);
2112
2113 f = (f | (f << 4U)) & 0x0F0FU;
2114 f = (f | (f << 2U)) & 0x3333U;
2115 f = (f | (f << 1U)) & 0x5555U;
2116
2117 s = (s | (s << 4U)) & 0x0F0FU;
2118 s = (s | (s << 2U)) & 0x3333U;
2119 s = (s | (s << 1U)) & 0x5555U;
2120
2121 return (f | (s << 1U));
2122 }
2123#endif
2124
2125 //*****************************************************************************
2128 //*****************************************************************************
2129 template <typename T>
2130 ETL_CONSTEXPR14
2132 binary_interleave(T first, T second)
2133 {
2134 uint32_t f = uint32_t(first);
2135 uint32_t s = uint32_t(second);
2136
2137 f = (f | (f << 8U)) & 0x00FF00FFUL;
2138 f = (f | (f << 4U)) & 0x0F0F0F0FUL;
2139 f = (f | (f << 2U)) & 0x33333333UL;
2140 f = (f | (f << 1U)) & 0x55555555UL;
2141
2142 s = (s | (s << 8U)) & 0x00FF00FFUL;
2143 s = (s | (s << 4U)) & 0x0F0F0F0FUL;
2144 s = (s | (s << 2U)) & 0x33333333UL;
2145 s = (s | (s << 1U)) & 0x55555555UL;
2146
2147 return (f | (s << 1U));
2148 }
2149
2150#if ETL_USING_64BIT_TYPES
2151 //*****************************************************************************
2154 //*****************************************************************************
2155 template <typename T>
2156 ETL_CONSTEXPR14
2158 binary_interleave(T first, T second)
2159 {
2160 uint64_t f = uint64_t(first);
2161 uint64_t s = uint64_t(second);
2162
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;
2168
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;
2174
2175 return (f | (s << 1U));
2176 }
2177#endif
2178
2179 //*****************************************************************************
2182 //*****************************************************************************
2183 template <typename T>
2184 ETL_CONSTEXPR14
2186 binary_interleave(T first, T second)
2187 {
2188 return int64_t(binary_interleave(uint16_t(first), uint16_t(second)));
2189 }
2190
2191 //***************************************************************************
2194 //***************************************************************************
2195 template <typename T>
2196 ETL_CONSTEXPR typename etl::enable_if<etl::is_integral<T>::value, bool>::type
2197 is_odd(T value)
2198 {
2199 return ((static_cast<typename etl::make_unsigned<T>::type>(value) & 1U) != 0U);
2200 }
2201
2202 //***************************************************************************
2205 //***************************************************************************
2206 template <typename T>
2207 ETL_CONSTEXPR typename etl::enable_if<etl::is_integral<T>::value, bool>::type
2208 is_even(T value)
2209 {
2210 return ((static_cast<typename etl::make_unsigned<T>::type>(value) & 1U) == 0U);
2211 }
2212
2213 //***********************************
2214 template <typename T, size_t NBits>
2216 {
2217 public:
2218
2219 ETL_STATIC_ASSERT(NBits <= etl::integral_limits<T>::bits, "Mask exceeds type size");
2220
2221 static ETL_CONSTANT T value = static_cast<T>(etl::max_value_for_nbits<NBits>::value);
2222 };
2223
2224 template <typename T, size_t NBits>
2225 ETL_CONSTANT T lsb_mask<T, NBits>::value;
2226
2227 //***********************************
2228 template <typename T, size_t NBits>
2229 ETL_CONSTEXPR T make_lsb_mask()
2230 {
2231 ETL_STATIC_ASSERT(NBits <= etl::integral_limits<T>::bits, "Mask exceeds type size");
2232
2234 }
2235
2236 //***********************************
2237 template <typename T>
2238 ETL_CONSTEXPR T make_lsb_mask(size_t nbits)
2239 {
2240 typedef typename etl::make_unsigned<T>::type type;
2241
2242 return (nbits == 0U) ? static_cast<T>(0)
2243 : static_cast<T>(static_cast<type>(~0) >> (etl::integral_limits<type>::bits - nbits));
2244 }
2245
2246 //***********************************
2247 template <typename T, size_t NBits>
2249 {
2250 public:
2251
2252 ETL_STATIC_ASSERT(NBits <= etl::integral_limits<T>::bits, "Mask exceeds type size");
2253
2254 static ETL_CONSTANT T value = static_cast<T>(etl::reverse_bits_const<T, lsb_mask<T, NBits>::value>::value);
2255 };
2256
2257 template <typename T, size_t NBits>
2258 ETL_CONSTANT T msb_mask<T, NBits>::value;
2259
2260 //***********************************
2261 template <typename T>
2262 ETL_CONSTEXPR T make_msb_mask(size_t nbits)
2263 {
2264 typedef typename etl::make_unsigned<T>::type type;
2265
2266 return (nbits == 0U) ? static_cast<T>(0)
2267 : static_cast<T>(static_cast<type>(~0) << (etl::integral_limits<type>::bits - nbits));
2268 }
2269
2270 //***********************************
2271 template <typename T, size_t NBits>
2272 ETL_CONSTEXPR T make_msb_mask()
2273 {
2274 ETL_STATIC_ASSERT(NBits <= etl::integral_limits<T>::bits, "Mask exceeds type size");
2275
2276 return msb_mask<T, NBits>::value;
2277 }
2278
2279 //***************************************************************************
2282 //***************************************************************************
2283 template <typename T>
2284 struct binary_not : public etl::unary_function<T, T>
2285 {
2286 //***********************************
2287 ETL_NODISCARD
2288 ETL_CONSTEXPR
2289 T operator ()(T value) const ETL_NOEXCEPT
2290 {
2291 ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
2292
2293 return ~value;
2294 }
2295 };
2296
2297 //***************************************************************************
2300 //***************************************************************************
2301 template <typename T>
2302 struct binary_and : public etl::unary_function<T, T>
2303 {
2304 //***********************************
2305 ETL_CONSTEXPR
2306 explicit binary_and(T parameter_) ETL_NOEXCEPT
2307 : parameter(parameter_)
2308 {
2309 }
2310
2311 //***********************************
2312 ETL_NODISCARD
2313 ETL_CONSTEXPR
2314 T operator ()(T value) const ETL_NOEXCEPT
2315 {
2316 ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
2317
2318 return value & parameter;
2319 }
2320
2321 private:
2322
2323 T parameter;
2324 };
2325
2326 //***************************************************************************
2329 //***************************************************************************
2330 template <typename T>
2331 struct binary_or : public etl::unary_function<T, T>
2332 {
2333 //***********************************
2334 ETL_CONSTEXPR
2335 explicit binary_or(T parameter_) ETL_NOEXCEPT
2336 : parameter(parameter_)
2337 {
2338 }
2339
2340 //***********************************
2341 ETL_NODISCARD
2342 ETL_CONSTEXPR
2343 T operator ()(T value) const ETL_NOEXCEPT
2344 {
2345 ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
2346
2347 return value | parameter;
2348 }
2349
2350 private:
2351
2352 T parameter;
2353 };
2354
2355 //***************************************************************************
2358 //***************************************************************************
2359 template <typename T>
2360 struct binary_xor : public etl::unary_function<T, T>
2361 {
2362 //***********************************
2363 ETL_CONSTEXPR
2364 explicit binary_xor(T parameter_) ETL_NOEXCEPT
2365 : parameter(parameter_)
2366 {
2367 }
2368
2369 //***********************************
2370 ETL_NODISCARD
2371 ETL_CONSTEXPR
2372 T operator ()(T value) const ETL_NOEXCEPT
2373 {
2374 ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
2375
2376 return value ^ parameter;
2377 }
2378
2379 private:
2380
2381 T parameter;
2382 };
2383
2384 //***************************************************************************
2387 //***************************************************************************
2389 {
2390 b00000000 = 0U,
2391 b00000001 = 1U,
2392 b00000010 = 2U,
2393 b00000011 = 3U,
2394 b00000100 = 4U,
2395 b00000101 = 5U,
2396 b00000110 = 6U,
2397 b00000111 = 7U,
2398 b00001000 = 8U,
2399 b00001001 = 9U,
2400 b00001010 = 10U,
2401 b00001011 = 11U,
2402 b00001100 = 12U,
2403 b00001101 = 13U,
2404 b00001110 = 14U,
2405 b00001111 = 15U,
2406 b00010000 = 16U,
2407 b00010001 = 17U,
2408 b00010010 = 18U,
2409 b00010011 = 19U,
2410 b00010100 = 20U,
2411 b00010101 = 21U,
2412 b00010110 = 22U,
2413 b00010111 = 23U,
2414 b00011000 = 24U,
2415 b00011001 = 25U,
2416 b00011010 = 26U,
2417 b00011011 = 27U,
2418 b00011100 = 28U,
2419 b00011101 = 29U,
2420 b00011110 = 30U,
2421 b00011111 = 31U,
2422 b00100000 = 32U,
2423 b00100001 = 33U,
2424 b00100010 = 34U,
2425 b00100011 = 35U,
2426 b00100100 = 36U,
2427 b00100101 = 37U,
2428 b00100110 = 38U,
2429 b00100111 = 39U,
2430 b00101000 = 40U,
2431 b00101001 = 41U,
2432 b00101010 = 42U,
2433 b00101011 = 43U,
2434 b00101100 = 44U,
2435 b00101101 = 45U,
2436 b00101110 = 46U,
2437 b00101111 = 47U,
2438 b00110000 = 48U,
2439 b00110001 = 49U,
2440 b00110010 = 50U,
2441 b00110011 = 51U,
2442 b00110100 = 52U,
2443 b00110101 = 53U,
2444 b00110110 = 54U,
2445 b00110111 = 55U,
2446 b00111000 = 56U,
2447 b00111001 = 57U,
2448 b00111010 = 58U,
2449 b00111011 = 59U,
2450 b00111100 = 60U,
2451 b00111101 = 61U,
2452 b00111110 = 62U,
2453 b00111111 = 63U,
2454 b01000000 = 64U,
2455 b01000001 = 65U,
2456 b01000010 = 66U,
2457 b01000011 = 67U,
2458 b01000100 = 68U,
2459 b01000101 = 69U,
2460 b01000110 = 70U,
2461 b01000111 = 71U,
2462 b01001000 = 72U,
2463 b01001001 = 73U,
2464 b01001010 = 74U,
2465 b01001011 = 75U,
2466 b01001100 = 76U,
2467 b01001101 = 77U,
2468 b01001110 = 78U,
2469 b01001111 = 79U,
2470 b01010000 = 80U,
2471 b01010001 = 81U,
2472 b01010010 = 82U,
2473 b01010011 = 83U,
2474 b01010100 = 84U,
2475 b01010101 = 85U,
2476 b01010110 = 86U,
2477 b01010111 = 87U,
2478 b01011000 = 88U,
2479 b01011001 = 89U,
2480 b01011010 = 90U,
2481 b01011011 = 91U,
2482 b01011100 = 92U,
2483 b01011101 = 93U,
2484 b01011110 = 94U,
2485 b01011111 = 95U,
2486 b01100000 = 96U,
2487 b01100001 = 97U,
2488 b01100010 = 98U,
2489 b01100011 = 99U,
2490 b01100100 = 100U,
2491 b01100101 = 101U,
2492 b01100110 = 102U,
2493 b01100111 = 103U,
2494 b01101000 = 104U,
2495 b01101001 = 105U,
2496 b01101010 = 106U,
2497 b01101011 = 107U,
2498 b01101100 = 108U,
2499 b01101101 = 109U,
2500 b01101110 = 110U,
2501 b01101111 = 111U,
2502 b01110000 = 112U,
2503 b01110001 = 113U,
2504 b01110010 = 114U,
2505 b01110011 = 115U,
2506 b01110100 = 116U,
2507 b01110101 = 117U,
2508 b01110110 = 118U,
2509 b01110111 = 119U,
2510 b01111000 = 120U,
2511 b01111001 = 121U,
2512 b01111010 = 122U,
2513 b01111011 = 123U,
2514 b01111100 = 124U,
2515 b01111101 = 125U,
2516 b01111110 = 126U,
2517 b01111111 = 127U,
2518 b10000000 = 128U,
2519 b10000001 = 129U,
2520 b10000010 = 130U,
2521 b10000011 = 131U,
2522 b10000100 = 132U,
2523 b10000101 = 133U,
2524 b10000110 = 134U,
2525 b10000111 = 135U,
2526 b10001000 = 136U,
2527 b10001001 = 137U,
2528 b10001010 = 138U,
2529 b10001011 = 139U,
2530 b10001100 = 140U,
2531 b10001101 = 141U,
2532 b10001110 = 142U,
2533 b10001111 = 143U,
2534 b10010000 = 144U,
2535 b10010001 = 145U,
2536 b10010010 = 146U,
2537 b10010011 = 147U,
2538 b10010100 = 148U,
2539 b10010101 = 149U,
2540 b10010110 = 150U,
2541 b10010111 = 151U,
2542 b10011000 = 152U,
2543 b10011001 = 153U,
2544 b10011010 = 154U,
2545 b10011011 = 155U,
2546 b10011100 = 156U,
2547 b10011101 = 157U,
2548 b10011110 = 158U,
2549 b10011111 = 159U,
2550 b10100000 = 160U,
2551 b10100001 = 161U,
2552 b10100010 = 162U,
2553 b10100011 = 163U,
2554 b10100100 = 164U,
2555 b10100101 = 165U,
2556 b10100110 = 166U,
2557 b10100111 = 167U,
2558 b10101000 = 168U,
2559 b10101001 = 169U,
2560 b10101010 = 170U,
2561 b10101011 = 171U,
2562 b10101100 = 172U,
2563 b10101101 = 173U,
2564 b10101110 = 174U,
2565 b10101111 = 175U,
2566 b10110000 = 176U,
2567 b10110001 = 177U,
2568 b10110010 = 178U,
2569 b10110011 = 179U,
2570 b10110100 = 180U,
2571 b10110101 = 181U,
2572 b10110110 = 182U,
2573 b10110111 = 183U,
2574 b10111000 = 184U,
2575 b10111001 = 185U,
2576 b10111010 = 186U,
2577 b10111011 = 187U,
2578 b10111100 = 188U,
2579 b10111101 = 189U,
2580 b10111110 = 190U,
2581 b10111111 = 191U,
2582 b11000000 = 192U,
2583 b11000001 = 193U,
2584 b11000010 = 194U,
2585 b11000011 = 195U,
2586 b11000100 = 196U,
2587 b11000101 = 197U,
2588 b11000110 = 198U,
2589 b11000111 = 199U,
2590 b11001000 = 200U,
2591 b11001001 = 201U,
2592 b11001010 = 202U,
2593 b11001011 = 203U,
2594 b11001100 = 204U,
2595 b11001101 = 205U,
2596 b11001110 = 206U,
2597 b11001111 = 207U,
2598 b11010000 = 208U,
2599 b11010001 = 209U,
2600 b11010010 = 210U,
2601 b11010011 = 211U,
2602 b11010100 = 212U,
2603 b11010101 = 213U,
2604 b11010110 = 214U,
2605 b11010111 = 215U,
2606 b11011000 = 216U,
2607 b11011001 = 217U,
2608 b11011010 = 218U,
2609 b11011011 = 219U,
2610 b11011100 = 220U,
2611 b11011101 = 221U,
2612 b11011110 = 222U,
2613 b11011111 = 223U,
2614 b11100000 = 224U,
2615 b11100001 = 225U,
2616 b11100010 = 226U,
2617 b11100011 = 227U,
2618 b11100100 = 228U,
2619 b11100101 = 229U,
2620 b11100110 = 230U,
2621 b11100111 = 231U,
2622 b11101000 = 232U,
2623 b11101001 = 233U,
2624 b11101010 = 234U,
2625 b11101011 = 235U,
2626 b11101100 = 236U,
2627 b11101101 = 237U,
2628 b11101110 = 238U,
2629 b11101111 = 239U,
2630 b11110000 = 240U,
2631 b11110001 = 241U,
2632 b11110010 = 242U,
2633 b11110011 = 243U,
2634 b11110100 = 244U,
2635 b11110101 = 245U,
2636 b11110110 = 246U,
2637 b11110111 = 247U,
2638 b11111000 = 248U,
2639 b11111001 = 249U,
2640 b11111010 = 250U,
2641 b11111011 = 251U,
2642 b11111100 = 252U,
2643 b11111101 = 253U,
2644 b11111110 = 254U,
2645 b11111111 = 255U
2646 };
2647
2648 //***************************************************************************
2651 //***************************************************************************
2653 {
2654 b0 = 0x1UL,
2655 b1 = 0x2UL,
2656 b2 = 0x4UL,
2657 b3 = 0x8UL,
2658 b4 = 0x10UL,
2659 b5 = 0x20UL,
2660 b6 = 0x40UL,
2661 b7 = 0x80UL,
2662 b8 = 0x100UL,
2663 b9 = 0x200UL,
2664 b10 = 0x400UL,
2665 b11 = 0x800UL,
2666 b12 = 0x1000UL,
2667 b13 = 0x2000UL,
2668 b14 = 0x4000UL,
2669 b15 = 0x8000UL,
2670 b16 = 0x10000UL,
2671 b17 = 0x20000UL,
2672 b18 = 0x40000UL,
2673 b19 = 0x80000UL,
2674 b20 = 0x100000UL,
2675 b21 = 0x200000UL,
2676 b22 = 0x400000UL,
2677 b23 = 0x800000UL,
2678 b24 = 0x1000000UL,
2679 b25 = 0x2000000UL,
2680 b26 = 0x4000000UL,
2681 b27 = 0x8000000UL,
2682 b28 = 0x10000000UL,
2683 b29 = 0x20000000UL,
2684 b30 = 0x40000000UL,
2685 b31 = 0x80000000UL
2686 };
2687}
2688
2689#endif
Definition binary.h:2216
Definition binary.h:2249
Definition binary.h:60
Definition binary.h:74
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 binary.h:2303
Definition binary.h:2285
Definition binary.h:2332
Definition binary.h:2361
Definition binary.h:353
Definition for non-zero NBITS.
Definition binary.h:90
Definition binary.h:480
#define ETL_ASSERT(b, e)
Definition error_handler.h:356
Definition exception.h:47
Definition integral_limits.h:516
Definition power.h:62
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