Embedded Template Library  1.0
binary.h
Go to the documentation of this file.
1 
3 /******************************************************************************
4 The MIT License(MIT)
5 
6 Embedded Template Library.
7 https://github.com/ETLCPP/etl
8 https://www.etlcpp.com
9 
10 Copyright(c) 2015 jwellbelove
11 
12 Permission is hereby granted, free of charge, to any person obtaining a copy
13 of this software and associated documentation files(the "Software"), to deal
14 in the Software without restriction, including without limitation the rights
15 to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
16 copies of the Software, and to permit persons to whom the Software is
17 furnished to do so, subject to the following conditions :
18 
19 The above copyright notice and this permission notice shall be included in all
20 copies or substantial portions of the Software.
21 
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
25 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28 SOFTWARE.
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 #undef ETL_FILE
50 #define ETL_FILE "50"
51 
52 namespace etl
53 {
54  //***************************************************************************
57  //***************************************************************************
59  {
60  public:
61 
62  binary_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
63  : exception(reason_, file_name_, line_number_)
64  {
65  }
66  };
67 
68  //***************************************************************************
71  //***************************************************************************
73  {
74  public:
75 
76  binary_out_of_range(string_type file_name_, numeric_type line_number_)
77  : etl::binary_exception(ETL_ERROR_TEXT("binary:out of range", ETL_FILE"A"), file_name_, line_number_)
78  {
79  }
80  };
81 
82  //***************************************************************************
85  //***************************************************************************
87  template <const size_t NBITS>
89  {
90  typedef typename etl::smallest_uint_for_bits<NBITS>::type value_type;
91  static const value_type value = (value_type(1) << (NBITS - 1)) | max_value_for_nbits<NBITS - 1>::value;
92  };
93 
95  template <>
97  {
98  typedef etl::smallest_uint_for_bits<0>::type value_type;
99  static const value_type value = 0;
100  };
101 
102  template <const size_t NBITS>
103  const typename max_value_for_nbits<NBITS>::value_type max_value_for_nbits<NBITS>::value;
104 
105 #if ETL_CPP17_SUPPORTED
106  template <const size_t NBITS>
107  inline constexpr typename etl::max_value_for_nbits<NBITS>::value_type max_value_for_nbits_v = max_value_for_nbits<NBITS>::value;
108 #endif
109 
110  //***************************************************************************
113  //***************************************************************************
114  template <typename T>
115  ETL_CONSTEXPR14 T rotate_left(T value)
116  {
117  ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
118 
119  const size_t SHIFT = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits - 1;
120 
121  return (value << 1) | (value >> SHIFT);
122  }
123 
124  //***************************************************************************
127  //***************************************************************************
128  template <typename T>
129  ETL_CONSTEXPR14 T rotate_left(T value, size_t distance)
130  {
131  ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
132 
134  distance %= BITS;
135  const size_t SHIFT = BITS - distance;
136 
137  return (value << distance) | (value >> SHIFT);
138  }
139 
140  //***************************************************************************
143  //***************************************************************************
144  template <typename T>
145  ETL_CONSTEXPR14 T rotate_right(T value)
146  {
147  ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
148 
149  const size_t SHIFT = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits - 1;
150 
151  return (value >> 1) | (value << SHIFT);
152  }
153 
154  //***************************************************************************
157  //***************************************************************************
158  template <typename T>
159  ETL_CONSTEXPR14 T rotate_right(T value, size_t distance)
160  {
161  ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
162 
164  distance %= BITS;
165  const size_t SHIFT = BITS - distance;
166 
167  return (value >> distance) | (value << SHIFT);
168  }
169 
170  //***************************************************************************
174  //***************************************************************************
175  template <typename T>
176  ETL_CONSTEXPR14 T rotate(T value, typename etl::make_signed<size_t>::type distance)
177  {
178  ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
179 
180  T result = T();
181 
182  if (distance > 0)
183  {
184  result = rotate_left(value, size_t(distance));
185  }
186  else
187  {
188  result = rotate_right(value, size_t(-distance));
189  }
190 
191  return result;
192  }
193 
194  //***************************************************************************
197  //***************************************************************************
198  template <typename T>
199  ETL_CONSTEXPR T binary_to_gray(T value)
200  {
201  ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
202 
203  return (value >> 1) ^ value;
204  }
205 
206  //***************************************************************************
209  //***************************************************************************
210  template <typename TReturn, const size_t NBITS, typename TValue>
211  ETL_CONSTEXPR14 TReturn fold_bits(TValue value)
212  {
213  ETL_STATIC_ASSERT(integral_limits<TReturn>::bits >= NBITS, "Return type too small to hold result");
214 
215  const TValue mask = etl::power<2, NBITS>::value - 1;
216  const size_t shift = NBITS;
217 
218  // Fold the value down to fit the width.
219  TReturn folded_value = 0;
220 
221  // Keep shifting down and XORing the lower bits.
223  {
224  folded_value ^= value & mask;
225  value >>= shift;
226  }
227 
228  // Fold the remaining bits.
229  folded_value ^= value & mask;
230 
231  return folded_value;
232  }
233 
234  //***************************************************************************
238  //***************************************************************************
239  template <typename TReturn, const size_t NBITS, typename TValue>
240  ETL_CONSTEXPR14 TReturn sign_extend(TValue value)
241  {
242  ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
243  ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
244  ETL_STATIC_ASSERT(NBITS <= etl::integral_limits<TReturn>::bits, "NBITS too large for return type");
245 
246  struct S
247  {
248  signed value : NBITS;
249  } s = {0};
250 
251  return (s.value = value);
252  }
253 
254  //***************************************************************************
259  //***************************************************************************
260  template <typename TReturn, const size_t NBITS, const size_t SHIFT, typename TValue>
261  ETL_CONSTEXPR14 TReturn sign_extend(TValue value)
262  {
263  ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
264  ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
265  ETL_STATIC_ASSERT(NBITS <= etl::integral_limits<TReturn>::bits, "NBITS too large for return type");
266  ETL_STATIC_ASSERT(SHIFT <= etl::integral_limits<TReturn>::bits, "SHIFT too large");
267 
268  struct S
269  {
270  signed value : NBITS;
271  } s = {0};
272 
273  return (s.value = (value >> SHIFT));
274  }
275 
276  //***************************************************************************
280  //***************************************************************************
281  template <typename TReturn, typename TValue>
282  ETL_CONSTEXPR14 TReturn sign_extend(TValue value, const size_t NBITS)
283  {
284  ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
285  ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
286 
288 
289  TReturn mask = TReturn(1) << (NBITS - 1);
290  value = value & TValue((TValue(1) << NBITS) - 1);
291 
292  return TReturn((value ^ mask) - mask);
293  }
294 
295  //***************************************************************************
300  //***************************************************************************
301  template <typename TReturn, typename TValue>
302  ETL_CONSTEXPR14 TReturn sign_extend(TValue value, const size_t NBITS, const size_t SHIFT)
303  {
304  ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
305  ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
306 
308 
309  TReturn mask = TReturn(1) << (NBITS - 1);
310  value = (value >> SHIFT) & TValue((TValue(1) << NBITS) - 1);
311 
312  return TReturn((value ^ mask) - mask);
313  }
314 
315  //***************************************************************************
319  //***************************************************************************
320  template <typename T>
321  ETL_CONSTEXPR14 uint_least8_t first_set_bit_position(T value)
322  {
323  return count_trailing_zeros(value);
324  }
325 
326  //***************************************************************************
330  //***************************************************************************
331  template <typename T>
332  ETL_CONSTEXPR14 uint_least8_t first_clear_bit_position(T value)
333  {
334  value = ~value;
335  return count_trailing_zeros(value);
336  }
337 
338  //***************************************************************************
342  //***************************************************************************
343  template <typename T>
344  ETL_CONSTEXPR14 uint_least8_t first_bit_position(bool state, T value)
345  {
346  if (!state)
347  {
348  value = ~value;
349  }
350 
351  return count_trailing_zeros(value);
352  }
353 
354  //***************************************************************************
358  //***************************************************************************
359  template <const size_t POSITION>
360  struct bit
361  {
362  typedef typename etl::smallest_uint_for_bits<POSITION + 1>::type value_type;
363  static const value_type value = value_type(1) << POSITION;
364  };
365 
366  template <const size_t POSITION>
367  const typename bit<POSITION>::value_type bit<POSITION>::value;
368 
369 #if ETL_CPP17_SUPPORTED
370  template <const size_t POSITION>
371  inline constexpr typename bit<POSITION>::value_type bit_v = bit<POSITION>::value;
372 #endif
373 
374  //***************************************************************************
377  //***************************************************************************
378  template <typename TResult, typename TValue>
379  ETL_CONSTEXPR TResult binary_fill(TValue value)
380  {
381  ETL_STATIC_ASSERT(sizeof(TResult) >= sizeof(TValue), "Result must be at least as large as the fill value");
382 
383  typedef typename etl::make_unsigned<TResult>::type unsigned_r_t;
384  typedef typename etl::make_unsigned<TValue>::type unsigned_v_t;
385 
386  return TResult(unsigned_v_t(value) * (unsigned_r_t(~unsigned_r_t(0U)) / unsigned_v_t(~unsigned_v_t(0U))));
387  }
388 
389  //***************************************************************************
392  //***************************************************************************
393  template <typename TResult, typename TValue, const TValue N>
394  ETL_CONSTEXPR TResult binary_fill()
395  {
396  ETL_STATIC_ASSERT(sizeof(TResult) >= sizeof(TValue), "Result must be at least as large as the fill value");
397 
398  typedef typename etl::make_unsigned<TResult>::type unsigned_r_t;
399  typedef typename etl::make_unsigned<TValue>::type unsigned_v_t;
400 
401  return TResult(unsigned_v_t(N) * (unsigned_r_t(~unsigned_r_t(0U)) / unsigned_v_t(~unsigned_v_t(0U))));
402  }
403 
404 #if ETL_8BIT_SUPPORT
405  //***************************************************************************
408  //***************************************************************************
409  template <typename TValue>
410  ETL_CONSTEXPR14 bool has_zero_byte(const TValue value)
411  {
412  typedef typename etl::make_unsigned<TValue>::type unsigned_t;
413  const unsigned_t mask = etl::binary_fill<unsigned_t, uint8_t>(0x7FU);
414  const unsigned_t temp = unsigned_t(~((((unsigned_t(value) & mask) + mask) | unsigned_t(value)) | mask));
415 
416  return (temp != 0U);
417  }
418 
419  //***************************************************************************
422  //***************************************************************************
423  template <typename TValue, const TValue N>
424  ETL_CONSTEXPR14 bool has_zero_byte()
425  {
426  typedef typename etl::make_unsigned<TValue>::type unsigned_t;
427  const unsigned_t mask = etl::binary_fill<unsigned_t, uint8_t>(0x7FU);
428  const unsigned_t temp = unsigned_t(~((((unsigned_t(N) & mask) + mask) | unsigned_t(N)) | mask));
429 
430  return (temp != 0U);
431  }
432 
433  //***************************************************************************
436  //***************************************************************************
437  template <typename TValue>
438  ETL_CONSTEXPR14 bool has_byte_n(TValue value, uint8_t n)
439  {
440  return etl::has_zero_byte(TValue(value ^ etl::binary_fill<TValue, uint8_t>(n)));
441  }
442 
443  //***************************************************************************
446  //***************************************************************************
447  template <typename TValue, const TValue N>
448  ETL_CONSTEXPR14 bool has_byte_n(TValue value)
449  {
450  return etl::has_zero_byte(TValue(value ^ etl::binary_fill<TValue, uint8_t>(N)));
451  }
452 #endif
453 
454  //***************************************************************************
459  //***************************************************************************
460  template <typename T>
461  ETL_CONSTEXPR T binary_merge(const T first, const T second, const T mask)
462  {
463  return second ^ ((second ^ first) & mask);
464  }
465 
466  //***************************************************************************
471  //***************************************************************************
472  template <typename T, const T MASK>
473  ETL_CONSTEXPR T binary_merge(const T first, const T second)
474  {
475  return second ^ ((second ^ first) & MASK);
476  }
477 
478 #if ETL_8BIT_SUPPORT
479  //***************************************************************************
482  //***************************************************************************
483  inline ETL_CONSTEXPR14 uint8_t reverse_bits(uint8_t value)
484  {
485  value = ((value & 0xAA) >> 1) | ((value & 0x55) << 1);
486  value = ((value & 0xCC) >> 2) | ((value & 0x33) << 2);
487  value = (value >> 4) | (value << 4);
488 
489  return value;
490  }
491 
492  inline ETL_CONSTEXPR14 int8_t reverse_bits(int8_t value)
493  {
494  return int8_t(reverse_bits(uint8_t(value)));
495  }
496 #endif
497 
498  //***************************************************************************
501  //***************************************************************************
502  inline ETL_CONSTEXPR14 uint16_t reverse_bits(uint16_t value)
503  {
504  value = ((value & 0xAAAA) >> 1) | ((value & 0x5555) << 1);
505  value = ((value & 0xCCCC) >> 2) | ((value & 0x3333) << 2);
506  value = ((value & 0xF0F0) >> 4) | ((value & 0x0F0F) << 4);
507  value = (value >> 8) | (value << 8);
508 
509  return value;
510  }
511 
512  inline ETL_CONSTEXPR14 int16_t reverse_bits(int16_t value)
513  {
514  return int16_t(reverse_bits(uint16_t(value)));
515  }
516 
517  //***************************************************************************
520  //***************************************************************************
521  inline ETL_CONSTEXPR14 uint32_t reverse_bits(uint32_t value)
522  {
523  value = ((value & 0xAAAAAAAA) >> 1) | ((value & 0x55555555) << 1);
524  value = ((value & 0xCCCCCCCC) >> 2) | ((value & 0x33333333) << 2);
525  value = ((value & 0xF0F0F0F0) >> 4) | ((value & 0x0F0F0F0F) << 4);
526  value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
527  value = (value >> 16) | (value << 16);
528 
529  return value;
530  }
531 
532  inline ETL_CONSTEXPR14 int32_t reverse_bits(int32_t value)
533  {
534  return int32_t(reverse_bits(uint32_t(value)));
535  }
536 
537 #if ETL_USING_64BIT_TYPES
538  //***************************************************************************
541  //***************************************************************************
542  inline ETL_CONSTEXPR14 uint64_t reverse_bits(uint64_t value)
543  {
544  value = ((value & 0xAAAAAAAAAAAAAAAA) >> 1) | ((value & 0x5555555555555555) << 1);
545  value = ((value & 0xCCCCCCCCCCCCCCCC) >> 2) | ((value & 0x3333333333333333) << 2);
546  value = ((value & 0xF0F0F0F0F0F0F0F0) >> 4) | ((value & 0x0F0F0F0F0F0F0F0F) << 4);
547  value = ((value & 0xFF00FF00FF00FF00) >> 8) | ((value & 0x00FF00FF00FF00FF) << 8);
548  value = ((value & 0xFFFF0000FFFF0000) >> 16) | ((value & 0x0000FFFF0000FFFF) << 16);
549  value = (value >> 32) | (value << 32);
550 
551  return value;
552  }
553 
554  inline ETL_CONSTEXPR14 int64_t reverse_bits(int64_t value)
555  {
556  return int64_t(reverse_bits(uint64_t(value)));
557  }
558 #endif
559 
560  //***************************************************************************
563  //***************************************************************************
564 #if ETL_8BIT_SUPPORT
565  inline ETL_CONSTEXPR uint8_t reverse_bytes(uint8_t value)
566  {
567  return value;
568  }
569 
570  inline ETL_CONSTEXPR int8_t reverse_bytes(int8_t value)
571  {
572  return value;
573  }
574 #endif
575 
576  //***************************************************************************
579  //***************************************************************************
580  inline ETL_CONSTEXPR uint16_t reverse_bytes(uint16_t value)
581  {
582  return (value >> 8) | (value << 8);
583  }
584 
585  inline ETL_CONSTEXPR int16_t reverse_bytes(int16_t value)
586  {
587  return int16_t(reverse_bytes(uint16_t(value)));
588  }
589 
590  //***************************************************************************
593  //***************************************************************************
594  inline ETL_CONSTEXPR14 uint32_t reverse_bytes(uint32_t value)
595  {
596  value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
597  value = (value >> 16) | (value << 16);
598 
599  return value;
600  }
601 
602  inline ETL_CONSTEXPR14 int32_t reverse_bytes(int32_t value)
603  {
604  return int32_t(reverse_bytes(uint32_t(value)));
605  }
606 
607 #if ETL_USING_64BIT_TYPES
608  //***************************************************************************
611  //***************************************************************************
612  inline ETL_CONSTEXPR14 uint64_t reverse_bytes(uint64_t value)
613  {
614  value = ((value & 0xFF00FF00FF00FF00) >> 8) | ((value & 0x00FF00FF00FF00FF) << 8);
615  value = ((value & 0xFFFF0000FFFF0000) >> 16) | ((value & 0x0000FFFF0000FFFF) << 16);
616  value = (value >> 32) | (value << 32);
617 
618  return value;
619  }
620 
621  inline ETL_CONSTEXPR14 int64_t reverse_bytes(int64_t value)
622  {
623  return int64_t(reverse_bytes(uint64_t(value)));
624  }
625 #endif
626 
627 #if ETL_8BIT_SUPPORT
628  //***************************************************************************
631  //***************************************************************************
632  inline ETL_CONSTEXPR14 uint8_t gray_to_binary(uint8_t value)
633  {
634  value ^= (value >> 4);
635  value ^= (value >> 2);
636  value ^= (value >> 1);
637 
638  return value;
639  }
640 
641  inline ETL_CONSTEXPR14 int8_t gray_to_binary(int8_t value)
642  {
643  return int8_t(gray_to_binary(uint8_t(value)));
644  }
645 #endif
646 
647  //***************************************************************************
650  //***************************************************************************
651  inline ETL_CONSTEXPR14 uint16_t gray_to_binary(uint16_t value)
652  {
653  value ^= (value >> 8);
654  value ^= (value >> 4);
655  value ^= (value >> 2);
656  value ^= (value >> 1);
657 
658  return value;
659  }
660 
661  inline ETL_CONSTEXPR14 int16_t gray_to_binary(int16_t value)
662  {
663  return int16_t(gray_to_binary(uint16_t(value)));
664  }
665 
666  //***************************************************************************
669  //***************************************************************************
670  inline ETL_CONSTEXPR14 uint32_t gray_to_binary(uint32_t value)
671  {
672  value ^= (value >> 16);
673  value ^= (value >> 8);
674  value ^= (value >> 4);
675  value ^= (value >> 2);
676  value ^= (value >> 1);
677 
678  return value;
679  }
680 
681  inline ETL_CONSTEXPR14 int32_t gray_to_binary(int32_t value)
682  {
683  return int32_t(gray_to_binary(uint32_t(value)));
684  }
685 
686 #if ETL_USING_64BIT_TYPES
687  //***************************************************************************
690  //***************************************************************************
691  inline ETL_CONSTEXPR14 uint64_t gray_to_binary(uint64_t value)
692  {
693  value ^= (value >> 32);
694  value ^= (value >> 16);
695  value ^= (value >> 8);
696  value ^= (value >> 4);
697  value ^= (value >> 2);
698  value ^= (value >> 1);
699 
700  return value;
701  }
702 
703  inline ETL_CONSTEXPR14 int64_t gray_to_binary(int64_t value)
704  {
705  return int64_t(gray_to_binary(uint64_t(value)));
706  }
707 #endif
708 
709 #if ETL_8BIT_SUPPORT
710  //***************************************************************************
713  //***************************************************************************
714  inline ETL_CONSTEXPR14 uint_least8_t count_bits(uint8_t value)
715  {
716  uint32_t count = 0U;
717 
718  count = value - ((value >> 1) & 0x55);
719  count = ((count >> 2) & 0x33) + (count & 0x33);
720  count = ((count >> 4) + count) & 0x0F;
721 
722  return uint_least8_t(count);
723  }
724 
725  inline ETL_CONSTEXPR14 uint_least8_t count_bits(int8_t value)
726  {
727  return count_bits(uint8_t(value));
728  }
729 
730 #endif
731 
732  //***************************************************************************
735  //***************************************************************************
736  inline ETL_CONSTEXPR14 uint_least8_t count_bits(uint16_t value)
737  {
738  uint32_t count = 0U;
739 
740  count = value - ((value >> 1) & 0x5555);
741  count = ((count >> 2) & 0x3333) + (count & 0x3333);
742  count = ((count >> 4) + count) & 0x0F0F;
743  count = ((count >> 8) + count) & 0x00FF;
744 
745  return count;
746  }
747 
748  inline ETL_CONSTEXPR14 uint_least8_t count_bits(int16_t value)
749  {
750  return count_bits(uint16_t(value));
751  }
752 
753  //***************************************************************************
756  //***************************************************************************
757  inline ETL_CONSTEXPR14 uint_least8_t count_bits(uint32_t value)
758  {
759  uint32_t count = 0U;
760 
761  count = value - ((value >> 1) & 0x55555555);
762  count = ((count >> 2) & 0x33333333) + (count & 0x33333333);
763  count = ((count >> 4) + count) & 0x0F0F0F0F;
764  count = ((count >> 8) + count) & 0x00FF00FF;
765  count = ((count >> 16) + count) & 0x0000FF;
766 
767  return uint_least8_t(count);
768  }
769 
770  inline ETL_CONSTEXPR14 uint_least8_t count_bits(int32_t value)
771  {
772  return count_bits(uint32_t(value));
773  }
774 
775 #if ETL_USING_64BIT_TYPES
776  //***************************************************************************
779  //***************************************************************************
780  inline ETL_CONSTEXPR14 uint_least8_t count_bits(uint64_t value)
781  {
782  uint64_t count = 0U;
783 
784  count = value - ((value >> 1) & 0x5555555555555555);
785  count = ((count >> 2) & 0x3333333333333333) + (count & 0x3333333333333333);
786  count = ((count >> 4) + count) & 0x0F0F0F0F0F0F0F0F;
787  count = ((count >> 8) + count) & 0x00FF00FF00FF00FF;
788  count = ((count >> 16) + count) & 0x0000FFFF0000FFFF;
789  count = ((count >> 32) + count) & 0x00000000FFFFFFFF;
790 
791  return uint_least8_t(count);
792  }
793 
794  inline ETL_CONSTEXPR14 uint_least8_t count_bits(int64_t value)
795  {
796  return count_bits(uint64_t(value));
797  }
798 #endif
799 
800 #if ETL_8BIT_SUPPORT
801  //***************************************************************************
804  //***************************************************************************
805  inline ETL_CONSTEXPR14 uint_least8_t parity(uint8_t value)
806  {
807  value ^= value >> 4;
808  value &= 0x0F;
809  return (0x6996 >> value) & 1;
810  }
811 
812  inline ETL_CONSTEXPR14 uint_least8_t parity(int8_t value)
813  {
814  return parity(uint8_t(value));
815  }
816 #endif
817 
818  //***************************************************************************
821  //***************************************************************************
822  inline ETL_CONSTEXPR14 uint_least8_t parity(uint16_t value)
823  {
824  value ^= value >> 8;
825  value ^= value >> 4;
826  value &= 0x0F;
827  return (0x6996 >> value) & 1;
828  }
829 
830  inline ETL_CONSTEXPR14 uint_least8_t parity(int16_t value)
831  {
832  return parity(uint16_t(value));
833  }
834 
835  //***************************************************************************
838  //***************************************************************************
839  inline ETL_CONSTEXPR14 uint_least8_t parity(uint32_t value)
840  {
841  value ^= value >> 16;
842  value ^= value >> 8;
843  value ^= value >> 4;
844  value &= 0x0F;
845  return (0x6996 >> value) & 1;
846  }
847 
848  inline ETL_CONSTEXPR14 uint_least8_t parity(int32_t value)
849  {
850  return parity(uint32_t(value));
851  }
852 
853 #if ETL_USING_64BIT_TYPES
854  //***************************************************************************
857  //***************************************************************************
858  inline ETL_CONSTEXPR14 uint_least8_t parity(uint64_t value)
859  {
860  value ^= value >> 32;
861  value ^= value >> 16;
862  value ^= value >> 8;
863  value ^= value >> 4;
864  value &= 0x0F;
865  return (0x69966996 >> value) & 1;
866  }
867 
868  inline ETL_CONSTEXPR14 uint_least8_t parity(int64_t value)
869  {
870  return parity(uint64_t(value));
871  }
872 #endif
873 
874 #if ETL_8BIT_SUPPORT
875  //***************************************************************************
879  //***************************************************************************
880  inline ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros(uint8_t value)
881  {
882  uint_least8_t count = 0U;
883 
884  if (value & 0x1)
885  {
886  count = 0;
887  }
888  else
889  {
890  count = 1;
891 
892  if ((value & 0xF) == 0)
893  {
894  value >>= 4;
895  count += 4;
896  }
897 
898  if ((value & 0x3) == 0)
899  {
900  value >>= 2;
901  count += 2;
902  }
903 
904  count -= value & 0x1;
905  }
906 
907  return count;
908  }
909 
910  inline ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros(int8_t value)
911  {
912  return count_trailing_zeros(uint8_t(value));
913  }
914 #endif
915 
916  //***************************************************************************
920  //***************************************************************************
921  inline ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros(uint16_t value)
922  {
923  uint_least8_t count = 0U;
924 
925  if (value & 0x1)
926  {
927  count = 0;
928  }
929  else
930  {
931  count = 1;
932 
933  if ((value & 0xFF) == 0)
934  {
935  value >>= 8;
936  count += 8;
937  }
938 
939  if ((value & 0xF) == 0)
940  {
941  value >>= 4;
942  count += 4;
943  }
944 
945  if ((value & 0x3) == 0)
946  {
947  value >>= 2;
948  count += 2;
949  }
950 
951  count -= value & 0x1;
952  }
953 
954  return count;
955  }
956 
957  inline ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros(int16_t value)
958  {
959  return count_trailing_zeros(uint16_t(value));
960  }
961 
962  //***************************************************************************
966  //***************************************************************************
967  inline ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros(uint32_t value)
968  {
969  uint_least8_t count = 0U;
970 
971  if (value & 0x1)
972  {
973  count = 0;
974  }
975  else
976  {
977  count = 1;
978 
979  if ((value & 0xFFFF) == 0)
980  {
981  value >>= 16;
982  count += 16;
983  }
984 
985  if ((value & 0xFF) == 0)
986  {
987  value >>= 8;
988  count += 8;
989  }
990 
991  if ((value & 0xF) == 0)
992  {
993  value >>= 4;
994  count += 4;
995  }
996 
997  if ((value & 0x3) == 0)
998  {
999  value >>= 2;
1000  count += 2;
1001  }
1002 
1003  count -= value & 0x1;
1004  }
1005 
1006  return count;
1007  }
1008 
1009  inline ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros(int32_t value)
1010  {
1011  return count_trailing_zeros(uint32_t(value));
1012  }
1013 
1014 #if ETL_USING_64BIT_TYPES
1015  //***************************************************************************
1019  //***************************************************************************
1020  ETL_CONSTEXPR14 inline uint_least8_t count_trailing_zeros(uint64_t value)
1021  {
1022  uint_least8_t count = 0U;
1023 
1024  if (value & 0x1)
1025  {
1026  count = 0;
1027  }
1028  else
1029  {
1030  count = 1;
1031 
1032  if ((value & 0xFFFFFFFF) == 0)
1033  {
1034  value >>= 32;
1035  count += 32;
1036  }
1037 
1038  if ((value & 0xFFFF) == 0)
1039  {
1040  value >>= 16;
1041  count += 16;
1042  }
1043 
1044  if ((value & 0xFF) == 0)
1045  {
1046  value >>= 8;
1047  count += 8;
1048  }
1049 
1050  if ((value & 0xF) == 0)
1051  {
1052  value >>= 4;
1053  count += 4;
1054  }
1055 
1056  if ((value & 0x3) == 0)
1057  {
1058  value >>= 2;
1059  count += 2;
1060  }
1061 
1062  count -= value & 0x1;
1063  }
1064 
1065  return count;
1066  }
1067 
1068  inline ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros(int64_t value)
1069  {
1070  return count_trailing_zeros(uint64_t(value));
1071  }
1072 #endif
1073 
1074 #if ETL_8BIT_SUPPORT
1075  //*****************************************************************************
1078  //*****************************************************************************
1079  inline ETL_CONSTEXPR14 uint16_t binary_interleave(uint8_t first, uint8_t second)
1080  {
1081  uint16_t f = first;
1082  uint16_t s = second;
1083 
1084  f = (f | (f << 4)) & 0x0F0F;
1085  f = (f | (f << 2)) & 0x3333;
1086  f = (f | (f << 1)) & 0x5555;
1087 
1088  s = (s | (s << 4)) & 0x0F0F;
1089  s = (s | (s << 2)) & 0x3333;
1090  s = (s | (s << 1)) & 0x5555;
1091 
1092  return (f | (s << 1));
1093  }
1094 
1095  inline ETL_CONSTEXPR14 int16_t binary_interleave(int8_t first, int8_t second)
1096  {
1097  return int16_t(binary_interleave(uint8_t(first), uint8_t(second)));
1098  }
1099 #endif
1100 
1101  //*****************************************************************************
1104  //*****************************************************************************
1105  inline ETL_CONSTEXPR14 uint32_t binary_interleave(uint16_t first, uint16_t second)
1106  {
1107  uint32_t f = first;
1108  uint32_t s = second;
1109 
1110  f = (f | (f << 8)) & 0x00FF00FF;
1111  f = (f | (f << 4)) & 0x0F0F0F0F;
1112  f = (f | (f << 2)) & 0x33333333;
1113  f = (f | (f << 1)) & 0x55555555;
1114 
1115  s = (s | (s << 8)) & 0x00FF00FF;
1116  s = (s | (s << 4)) & 0x0F0F0F0F;
1117  s = (s | (s << 2)) & 0x33333333;
1118  s = (s | (s << 1)) & 0x55555555;
1119 
1120  return (f | (s << 1));
1121  }
1122 
1123  inline ETL_CONSTEXPR14 int32_t binary_interleave(int16_t first, int16_t second)
1124  {
1125  return int32_t(binary_interleave(uint16_t(first), uint16_t(second)));
1126  }
1127 
1128 #if ETL_USING_64BIT_TYPES
1129  //*****************************************************************************
1132  //*****************************************************************************
1133  inline ETL_CONSTEXPR14 uint64_t binary_interleave(uint32_t first, uint32_t second)
1134  {
1135  uint64_t f = first;
1136  uint64_t s = second;
1137 
1138  f = (f | (f << 16)) & 0x0000FFFF0000FFFF;
1139  f = (f | (f << 8)) & 0x00FF00FF00FF00FF;
1140  f = (f | (f << 4)) & 0x0F0F0F0F0F0F0F0F;
1141  f = (f | (f << 2)) & 0x3333333333333333;
1142  f = (f | (f << 1)) & 0x5555555555555555;
1143 
1144  s = (s | (s << 16)) & 0x0000FFFF0000FFFF;
1145  s = (s | (s << 8)) & 0x00FF00FF00FF00FF;
1146  s = (s | (s << 4)) & 0x0F0F0F0F0F0F0F0F;
1147  s = (s | (s << 2)) & 0x3333333333333333;
1148  s = (s | (s << 1)) & 0x5555555555555555;
1149 
1150  return (f | (s << 1));
1151  }
1152 
1153  inline ETL_CONSTEXPR14 int64_t binary_interleave(int32_t first, int32_t second)
1154  {
1155  return int64_t(binary_interleave(uint16_t(first), uint16_t(second)));
1156  }
1157 #endif
1158 
1159  //***************************************************************************
1162  //***************************************************************************
1163  template <typename T>
1164  ETL_CONSTEXPR typename etl::enable_if<etl::is_integral<T>::value, bool>::type
1165  is_odd(const T value)
1166  {
1167  return ((static_cast<typename etl::make_unsigned<T>::type>(value) & 1U) != 0U);
1168  }
1169 
1170  //***************************************************************************
1173  //***************************************************************************
1174  template <typename T>
1175  ETL_CONSTEXPR typename etl::enable_if<etl::is_integral<T>::value, bool>::type
1176  is_even(const T value)
1177  {
1178  return ((static_cast<typename etl::make_unsigned<T>::type>(value) & 1U) == 0U);
1179  }
1180 
1181  //***************************************************************************
1184  //***************************************************************************
1186  {
1187  b00000000 = 0,
1188  b00000001 = 1,
1189  b00000010 = 2,
1190  b00000011 = 3,
1191  b00000100 = 4,
1192  b00000101 = 5,
1193  b00000110 = 6,
1194  b00000111 = 7,
1195  b00001000 = 8,
1196  b00001001 = 9,
1197  b00001010 = 10,
1198  b00001011 = 11,
1199  b00001100 = 12,
1200  b00001101 = 13,
1201  b00001110 = 14,
1202  b00001111 = 15,
1203  b00010000 = 16,
1204  b00010001 = 17,
1205  b00010010 = 18,
1206  b00010011 = 19,
1207  b00010100 = 20,
1208  b00010101 = 21,
1209  b00010110 = 22,
1210  b00010111 = 23,
1211  b00011000 = 24,
1212  b00011001 = 25,
1213  b00011010 = 26,
1214  b00011011 = 27,
1215  b00011100 = 28,
1216  b00011101 = 29,
1217  b00011110 = 30,
1218  b00011111 = 31,
1219  b00100000 = 32,
1220  b00100001 = 33,
1221  b00100010 = 34,
1222  b00100011 = 35,
1223  b00100100 = 36,
1224  b00100101 = 37,
1225  b00100110 = 38,
1226  b00100111 = 39,
1227  b00101000 = 40,
1228  b00101001 = 41,
1229  b00101010 = 42,
1230  b00101011 = 43,
1231  b00101100 = 44,
1232  b00101101 = 45,
1233  b00101110 = 46,
1234  b00101111 = 47,
1235  b00110000 = 48,
1236  b00110001 = 49,
1237  b00110010 = 50,
1238  b00110011 = 51,
1239  b00110100 = 52,
1240  b00110101 = 53,
1241  b00110110 = 54,
1242  b00110111 = 55,
1243  b00111000 = 56,
1244  b00111001 = 57,
1245  b00111010 = 58,
1246  b00111011 = 59,
1247  b00111100 = 60,
1248  b00111101 = 61,
1249  b00111110 = 62,
1250  b00111111 = 63,
1251  b01000000 = 64,
1252  b01000001 = 65,
1253  b01000010 = 66,
1254  b01000011 = 67,
1255  b01000100 = 68,
1256  b01000101 = 69,
1257  b01000110 = 70,
1258  b01000111 = 71,
1259  b01001000 = 72,
1260  b01001001 = 73,
1261  b01001010 = 74,
1262  b01001011 = 75,
1263  b01001100 = 76,
1264  b01001101 = 77,
1265  b01001110 = 78,
1266  b01001111 = 79,
1267  b01010000 = 80,
1268  b01010001 = 81,
1269  b01010010 = 82,
1270  b01010011 = 83,
1271  b01010100 = 84,
1272  b01010101 = 85,
1273  b01010110 = 86,
1274  b01010111 = 87,
1275  b01011000 = 88,
1276  b01011001 = 89,
1277  b01011010 = 90,
1278  b01011011 = 91,
1279  b01011100 = 92,
1280  b01011101 = 93,
1281  b01011110 = 94,
1282  b01011111 = 95,
1283  b01100000 = 96,
1284  b01100001 = 97,
1285  b01100010 = 98,
1286  b01100011 = 99,
1287  b01100100 = 100,
1288  b01100101 = 101,
1289  b01100110 = 102,
1290  b01100111 = 103,
1291  b01101000 = 104,
1292  b01101001 = 105,
1293  b01101010 = 106,
1294  b01101011 = 107,
1295  b01101100 = 108,
1296  b01101101 = 109,
1297  b01101110 = 110,
1298  b01101111 = 111,
1299  b01110000 = 112,
1300  b01110001 = 113,
1301  b01110010 = 114,
1302  b01110011 = 115,
1303  b01110100 = 116,
1304  b01110101 = 117,
1305  b01110110 = 118,
1306  b01110111 = 119,
1307  b01111000 = 120,
1308  b01111001 = 121,
1309  b01111010 = 122,
1310  b01111011 = 123,
1311  b01111100 = 124,
1312  b01111101 = 125,
1313  b01111110 = 126,
1314  b01111111 = 127,
1315  b10000000 = 128,
1316  b10000001 = 129,
1317  b10000010 = 130,
1318  b10000011 = 131,
1319  b10000100 = 132,
1320  b10000101 = 133,
1321  b10000110 = 134,
1322  b10000111 = 135,
1323  b10001000 = 136,
1324  b10001001 = 137,
1325  b10001010 = 138,
1326  b10001011 = 139,
1327  b10001100 = 140,
1328  b10001101 = 141,
1329  b10001110 = 142,
1330  b10001111 = 143,
1331  b10010000 = 144,
1332  b10010001 = 145,
1333  b10010010 = 146,
1334  b10010011 = 147,
1335  b10010100 = 148,
1336  b10010101 = 149,
1337  b10010110 = 150,
1338  b10010111 = 151,
1339  b10011000 = 152,
1340  b10011001 = 153,
1341  b10011010 = 154,
1342  b10011011 = 155,
1343  b10011100 = 156,
1344  b10011101 = 157,
1345  b10011110 = 158,
1346  b10011111 = 159,
1347  b10100000 = 160,
1348  b10100001 = 161,
1349  b10100010 = 162,
1350  b10100011 = 163,
1351  b10100100 = 164,
1352  b10100101 = 165,
1353  b10100110 = 166,
1354  b10100111 = 167,
1355  b10101000 = 168,
1356  b10101001 = 169,
1357  b10101010 = 170,
1358  b10101011 = 171,
1359  b10101100 = 172,
1360  b10101101 = 173,
1361  b10101110 = 174,
1362  b10101111 = 175,
1363  b10110000 = 176,
1364  b10110001 = 177,
1365  b10110010 = 178,
1366  b10110011 = 179,
1367  b10110100 = 180,
1368  b10110101 = 181,
1369  b10110110 = 182,
1370  b10110111 = 183,
1371  b10111000 = 184,
1372  b10111001 = 185,
1373  b10111010 = 186,
1374  b10111011 = 187,
1375  b10111100 = 188,
1376  b10111101 = 189,
1377  b10111110 = 190,
1378  b10111111 = 191,
1379  b11000000 = 192,
1380  b11000001 = 193,
1381  b11000010 = 194,
1382  b11000011 = 195,
1383  b11000100 = 196,
1384  b11000101 = 197,
1385  b11000110 = 198,
1386  b11000111 = 199,
1387  b11001000 = 200,
1388  b11001001 = 201,
1389  b11001010 = 202,
1390  b11001011 = 203,
1391  b11001100 = 204,
1392  b11001101 = 205,
1393  b11001110 = 206,
1394  b11001111 = 207,
1395  b11010000 = 208,
1396  b11010001 = 209,
1397  b11010010 = 210,
1398  b11010011 = 211,
1399  b11010100 = 212,
1400  b11010101 = 213,
1401  b11010110 = 214,
1402  b11010111 = 215,
1403  b11011000 = 216,
1404  b11011001 = 217,
1405  b11011010 = 218,
1406  b11011011 = 219,
1407  b11011100 = 220,
1408  b11011101 = 221,
1409  b11011110 = 222,
1410  b11011111 = 223,
1411  b11100000 = 224,
1412  b11100001 = 225,
1413  b11100010 = 226,
1414  b11100011 = 227,
1415  b11100100 = 228,
1416  b11100101 = 229,
1417  b11100110 = 230,
1418  b11100111 = 231,
1419  b11101000 = 232,
1420  b11101001 = 233,
1421  b11101010 = 234,
1422  b11101011 = 235,
1423  b11101100 = 236,
1424  b11101101 = 237,
1425  b11101110 = 238,
1426  b11101111 = 239,
1427  b11110000 = 240,
1428  b11110001 = 241,
1429  b11110010 = 242,
1430  b11110011 = 243,
1431  b11110100 = 244,
1432  b11110101 = 245,
1433  b11110110 = 246,
1434  b11110111 = 247,
1435  b11111000 = 248,
1436  b11111001 = 249,
1437  b11111010 = 250,
1438  b11111011 = 251,
1439  b11111100 = 252,
1440  b11111101 = 253,
1441  b11111110 = 254,
1442  b11111111 = 255
1443  };
1444 
1445 
1446  //***************************************************************************
1449  //***************************************************************************
1451  {
1452  b0 = 0x1,
1453  b1 = 0x2,
1454  b2 = 0x4,
1455  b3 = 0x8,
1456  b4 = 0x10,
1457  b5 = 0x20,
1458  b6 = 0x40,
1459  b7 = 0x80,
1460  b8 = 0x100,
1461  b9 = 0x200,
1462  b10 = 0x400,
1463  b11 = 0x800,
1464  b12 = 0x1000,
1465  b13 = 0x2000,
1466  b14 = 0x4000,
1467  b15 = 0x8000,
1468  b16 = 0x10000,
1469  b17 = 0x20000,
1470  b18 = 0x40000,
1471  b19 = 0x80000,
1472  b20 = 0x100000,
1473  b21 = 0x200000,
1474  b22 = 0x400000,
1475  b23 = 0x800000,
1476  b24 = 0x1000000,
1477  b25 = 0x2000000,
1478  b26 = 0x4000000,
1479  b27 = 0x8000000,
1480  b28 = 0x10000000,
1481  b29 = 0x20000000,
1482  b30 = 0x40000000,
1483  b31 = 0x80000000
1484  };
1485 }
1486 
1487 #undef ETL_FILE
1488 
1489 #endif
Definition: binary.h:59
Definition: binary.h:73
ETL_CONSTEXPR14 uint_least8_t count_bits(uint16_t value)
Definition: binary.h:736
ETL_CONSTEXPR TResult binary_fill(TValue value)
Definition: binary.h:379
ETL_CONSTEXPR14 uint_least8_t first_set_bit_position(T value)
Definition: binary.h:321
ETL_CONSTEXPR uint16_t reverse_bytes(uint16_t value)
Definition: binary.h:580
binary_constant
Definition: binary.h:1186
ETL_CONSTEXPR14 uint32_t binary_interleave(uint16_t first, uint16_t second)
Definition: binary.h:1105
ETL_CONSTEXPR14 uint16_t gray_to_binary(uint16_t value)
Definition: binary.h:651
ETL_CONSTEXPR14 T rotate_left(T value)
Definition: binary.h:115
ETL_CONSTEXPR14 uint_least8_t first_clear_bit_position(T value)
Definition: binary.h:332
ETL_CONSTEXPR14 TReturn fold_bits(TValue value)
Definition: binary.h:211
ETL_CONSTEXPR14 uint_least8_t parity(uint16_t value)
Definition: binary.h:822
ETL_CONSTEXPR T binary_merge(const T first, const T second, const T mask)
Definition: binary.h:461
ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros(uint16_t value)
Definition: binary.h:921
ETL_CONSTEXPR14 uint16_t reverse_bits(uint16_t value)
Definition: binary.h:502
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_odd(const T value)
Definition: binary.h:1165
ETL_CONSTEXPR14 TReturn sign_extend(TValue value)
Definition: binary.h:240
bit_constant
Definition: binary.h:1451
ETL_CONSTEXPR T binary_to_gray(T value)
Definition: binary.h:199
ETL_CONSTEXPR14 uint_least8_t first_bit_position(bool state, T value)
Definition: binary.h:344
ETL_CONSTEXPR14 T rotate_right(T value)
Definition: binary.h:145
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_even(const T value)
Definition: binary.h:1176
Definition: binary.h:361
Definition for non-zero NBITS.
Definition: binary.h:89
#define ETL_ASSERT(b, e)
Definition: error_handler.h:290
exception(string_type reason_, string_type file_, numeric_type line_)
Constructor.
Definition: exception.h:67
Definition: exception.h:47
Definition: integral_limits.h:54
Definition: power.h:62
enable_if
Definition: type_traits_generator.h:1228
is_integral
Definition: type_traits_generator.h:941
Definition: absolute.h:37