From c3603c4d7e29a275be81c3918fcc05a83d528e4c Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Wed, 29 Nov 2023 18:21:47 +0000
Subject: [PATCH 01/26] Improved display of CHECK_EQUAL_HEX in unittest++

---
 test/UnitTest++/Checks.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/test/UnitTest++/Checks.h b/test/UnitTest++/Checks.h
index a2571e02..88f1a1c3 100644
--- a/test/UnitTest++/Checks.h
+++ b/test/UnitTest++/Checks.h
@@ -190,7 +190,9 @@ namespace UnitTest
      if (!(expected == actual))
      {
        UnitTest::MemoryOutStream stream;
-       stream << std::hex << std::uppercase << std::setfill('0') << "Expected 0x" << std::setw(2 * sizeof(Expected)) << expected << " but was 0x" << std::setw(2 * sizeof(Actual)) << actual;
+       stream << std::hex << std::uppercase << std::setfill('0') 
+              << "Expected 0x" << std::setw(2 * sizeof(Expected)) << (expected & ~(typename std::make_unsigned<Expected>::type(0))) 
+              << " but was 0x" << std::setw(2 * sizeof(Actual))   << (actual   & ~(typename std::make_unsigned<Actual>::type(0)));
 
        results.OnTestFailure(details, stream.GetText());
      }
@@ -214,7 +216,8 @@ namespace UnitTest
      if (expected == actual)
      {
        UnitTest::MemoryOutStream stream;
-       stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2 * sizeof(Actual)) << "Expected not equal, but both values are " << actual;
+       stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2 * sizeof(Actual)) 
+              << "Expected not equal, but both values are " << (actual & ~(typename std::make_unsigned<Actual>::type(0)));
 
        results.OnTestFailure(details, stream.GetText());
      }

From 863dd24cc4713225d45f3ede0bc03103c684f18a Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Wed, 29 Nov 2023 18:22:34 +0000
Subject: [PATCH 02/26] Work in progress for etl::bitset::extract

---
 include/etl/private/bitset_new.h              | 309 +++++++++++++++++-
 test/test_bitset_new_default_element_type.cpp |  70 ++++
 ...itset_new_explicit_single_element_type.cpp |  69 ++++
 ...st_bitset_new_ext_default_element_type.cpp |  74 +++++
 ...t_new_ext_explicit_single_element_type.cpp |  74 +++++
 test/vs2022/etl.vcxproj                       |  22 +-
 test/vs2022/etl.vcxproj.filters               |  14 +-
 7 files changed, 597 insertions(+), 35 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 63462f21..058d8f45 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -192,7 +192,7 @@ namespace etl
       size_t    index = 0;
       element_type bit = 0;
 
-      if (number_of_elements == 0)
+      if (number_of_elements == 0) ETL_UNLIKELY
       {
         return;
       }
@@ -229,12 +229,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -259,12 +259,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -289,12 +289,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -319,12 +319,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -395,6 +395,141 @@ namespace etl
       return v;
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    T extract_from_single_element(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
+      const int        element_index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const unsigned_t Shift = position % Bits_Per_Element;
+
+      value = static_cast<unsigned_t>(pbuffer[element_index] >> Shift) & value_mask;
+
+      return static_cast<T>(value);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    T extract_from_multi_element(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      // The mask for the value type.
+      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
+
+      // Find the index of the element containing the msb.
+      int element_index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
+
+      // The value is spread over multiple elements.       
+      element_type bit_mask = element_type(1) << ((position + length - 1) % Bits_Per_Element);
+
+      while (length != 0)
+      {
+        // TODO Optimise this to read whole element values.
+
+        value <<= 1;
+
+        const bool is_set = (pbuffer[element_index] & bit_mask) != 0;
+
+        if (is_set)
+        {
+          value |= unsigned_t(1);
+        }
+
+        bit_mask >>= 1;
+
+        if (bit_mask == 0)
+        {
+          bit_mask = element_type(1) << (Bits_Per_Element - 1);
+          --element_index;
+        }
+
+        --length;
+      }
+
+      return static_cast<T>(value);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length>
+    ETL_CONSTEXPR14
+    T extract_from_single_element(const_pointer pbuffer) const
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      const unsigned_t value_mask    = etl::integral_limits<unsigned_t>::max;
+      const int        element_index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const unsigned_t Shift         = Position % Bits_Per_Element;
+
+      value = static_cast<unsigned_t>(pbuffer[element_index] >> Shift) & value_mask;
+
+      return static_cast<T>(value);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length>
+    ETL_CONSTEXPR14
+    T extract_from_multi_element(const_pointer pbuffer) const
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      // The mask for the value type.
+      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
+
+      // Find the index of the element containing the msb.
+      int element_index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+
+      // The value is spread over multiple elements.       
+      size_t       length   = Length;
+      element_type bit_mask = element_type(1) << ((Position + Length - 1) % Bits_Per_Element);
+
+      while (length != 0)
+      {
+        // TODO Optimise this to read whole element values.
+
+        value <<= 1;
+
+        const bool is_set = (pbuffer[element_index] & bit_mask) != 0;
+
+        if (is_set)
+        {
+          value |= unsigned_t(1);
+        }      
+
+        bit_mask >>= 1;
+
+        if (bit_mask == 0)
+        {
+          bit_mask = element_type(1) << (Bits_Per_Element - 1);
+          --element_index;
+        }
+
+        --length;
+      }
+
+      return static_cast<T>(value);
+    }
+
     //*************************************************************************
     /// Reset the bit at the position.
     //*************************************************************************
@@ -403,7 +538,7 @@ namespace etl
       size_t       index = 0U;
       element_type bit = element_type(0);
 
-      if (number_of_elements == 0)
+      if (number_of_elements == 0) ETL_UNLIKELY
       {
         return;
       }
@@ -440,7 +575,7 @@ namespace etl
       size_t       index = 0U;
       element_type bit = element_type(0);
       
-      if (number_of_elements == 0)
+      if (number_of_elements == 0) ETL_UNLIKELY
       {
         return;
       }
@@ -1251,7 +1386,7 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
       value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
@@ -1269,6 +1404,40 @@ namespace etl
       return v;
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+    {
+      ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
+
+      element_type mask = (~(~0u << length) << position);
+      T value((buffer & mask) >> position);
+
+      return value;
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract() const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
+      
+      element_type mask = (~(~0u << Length) << Position);
+      T value((buffer & mask) >> Position);
+
+      return value;
+    }
+
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
@@ -2027,6 +2196,42 @@ namespace etl
       return ibitset.template value<T>(buffer, Number_Of_Elements);
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+    {
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
+
+      return ibitset.extract_from_multi_element<T>(buffer, position, length);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+    ETL_CONSTEXPR14
+      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract() const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
+
+      const int active_bits_in_element = ((Position + Length) % Bits_Per_Element);
+
+      // Is the value contained within one element?
+      if (active_bits_in_element == Length)
+      {
+        return ibitset.extract_from_single_element<T, Position, Length>(buffer);
+      }
+      else
+      {
+        return ibitset.extract_from_multi_element<T, Position, Length>(buffer);
+      }
+    }
+
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
@@ -2963,7 +3168,7 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
       value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
@@ -2981,6 +3186,38 @@ namespace etl
       return v;
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+    {
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
+
+      element_type mask = (~(~0u << length) << position);
+      T v((*pbuffer & mask) >> position);
+
+      return v;
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+    ETL_CONSTEXPR14
+      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract() const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
+
+      element_type mask = (~(~0u << Length) << Position);
+      T v((*pbuffer & mask) >> Position);
+
+      return v;
+    }
+
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
@@ -3733,7 +3970,7 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
       value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
@@ -3742,6 +3979,42 @@ namespace etl
       return ibitset.template value<T>(pbuffer, Number_Of_Elements);
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+    {
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
+
+      return ibitset.extract_from_multi_element<T>(pbuffer, position, length);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract() const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
+
+      const int active_bits_in_element = ((Position + Length) % Bits_Per_Element);
+
+      // Is the value contained within one element?
+      if (active_bits_in_element == Length)
+      {
+        return ibitset.extract_from_single_element<T, Position, Length>(pbuffer);
+      }
+      else
+      {
+        return ibitset.extract_from_multi_element<T, Position, Length>(pbuffer);
+      }
+    }
+
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index 67f703a3..f41ac262 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -2096,5 +2096,75 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    //*************************************************************************
+    TEST(test_extract_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+      
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //uint8_t v = b.extract<uint8_t, 25, 8>();
+      //uint8_t v = b.extract<uint8_t, 25, 9>();
+    }
   };
 }
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index b9c0c84b..0f25e6da 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -1585,5 +1585,74 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    //*************************************************************************
+    TEST(test_extract_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL(0x78, b.extract<uint8_t>(0, 8));
+      CHECK_EQUAL(0x3C, b.extract<uint8_t>(1, 8));
+      CHECK_EQUAL(0x9E, b.extract<uint8_t>(2, 8));
+      CHECK_EQUAL(0xCF, b.extract<uint8_t>(3, 8));
+      CHECK_EQUAL(0x67, b.extract<uint8_t>(4, 8));
+      CHECK_EQUAL(0xB3, b.extract<uint8_t>(5, 8));
+      CHECK_EQUAL(0x59, b.extract<uint8_t>(6, 8));
+      CHECK_EQUAL(0xAC, b.extract<uint8_t>(7, 8));
+      CHECK_EQUAL(0x56, b.extract<uint8_t>(8, 8));
+      CHECK_EQUAL(0x2B, b.extract<uint8_t>(9, 8));
+      CHECK_EQUAL(0x15, b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL(0x8A, b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL(0x45, b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL(0xA2, b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL(0xD1, b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL(0x68, b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL(0x34, b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL(0x1A, b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL(0x8D, b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL(0x46, b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL(0x23, b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL(0x91, b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL(0x48, b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL(0x24, b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL(0x12, b.extract<uint8_t>(24, 8));
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL(0x78, (b.extract<uint8_t, 0, 8>()));
+      CHECK_EQUAL(0x3C, (b.extract<uint8_t, 1, 8>()));
+      CHECK_EQUAL(0x9E, (b.extract<uint8_t, 2, 8>()));
+      CHECK_EQUAL(0xCF, (b.extract<uint8_t, 3, 8>()));
+      CHECK_EQUAL(0x67, (b.extract<uint8_t, 4, 8>()));
+      CHECK_EQUAL(0xB3, (b.extract<uint8_t, 5, 8>()));
+      CHECK_EQUAL(0x59, (b.extract<uint8_t, 6, 8>()));
+      CHECK_EQUAL(0xAC, (b.extract<uint8_t, 7, 8>()));
+      CHECK_EQUAL(0x56, (b.extract<uint8_t, 8, 8>()));
+      CHECK_EQUAL(0x2B, (b.extract<uint8_t, 9, 8>()));
+      CHECK_EQUAL(0x15, (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL(0x8A, (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL(0x45, (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL(0xA2, (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL(0xD1, (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL(0x68, (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL(0x34, (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL(0x1A, (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL(0x8D, (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL(0x46, (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL(0x23, (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL(0x91, (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL(0x48, (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL(0x24, (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL(0x12, (b.extract<uint8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //uint8_t v = b.extract<uint8_t, 25, 8>();
+      //uint8_t v = b.extract<uint8_t, 25, 9>();
+    }
   };
 }
diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp
index aeeea766..c5e12541 100644
--- a/test/test_bitset_new_ext_default_element_type.cpp
+++ b/test/test_bitset_new_ext_default_element_type.cpp
@@ -1957,5 +1957,79 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    //*************************************************************************
+    TEST(test_extract_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+    }
+
+    //*************************************************************************
+    TEST(test_extract_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The line below should static assert.
+      //uint8_t v = b.extract<uint8_t, 25, 8>();
+      //uint8_t v = b.extract<uint8_t, 25, 9>();
+    }
   };
 }
diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp
index b7bc74ef..308259a4 100644
--- a/test/test_bitset_new_ext_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp
@@ -1309,5 +1309,79 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    //*************************************************************************
+    TEST(test_extract_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, int32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+    }
+
+    //*************************************************************************
+    TEST(test_extract_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, int32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The line below should static assert.
+      //uint8_t v = b.extract<uint8_t, 25, 8>();
+      //uint8_t v = b.extract<uint8_t, 25, 9>();
+    }
   };
 }
diff --git a/test/vs2022/etl.vcxproj b/test/vs2022/etl.vcxproj
index 50d71f98..346223ed 100644
--- a/test/vs2022/etl.vcxproj
+++ b/test/vs2022/etl.vcxproj
@@ -839,17 +839,17 @@
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - Force C++03|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No virtual messages|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
@@ -859,37 +859,37 @@
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++ 20 - No Tests|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
@@ -935,7 +935,7 @@
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14 - No STL|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
diff --git a/test/vs2022/etl.vcxproj.filters b/test/vs2022/etl.vcxproj.filters
index d4dfc25b..cea19458 100644
--- a/test/vs2022/etl.vcxproj.filters
+++ b/test/vs2022/etl.vcxproj.filters
@@ -3334,12 +3334,6 @@
     <None Include="..\..\appveyor.yml">
       <Filter>Resource Files\CI\Appveyor</Filter>
     </None>
-    <None Include="..\..\.github\workflows\clang.yml">
-      <Filter>Resource Files\CI\Github</Filter>
-    </None>
-    <None Include="..\..\.github\workflows\gcc.yml">
-      <Filter>Resource Files\CI\Github</Filter>
-    </None>
     <None Include="..\..\.clang-format">
       <Filter>Resource Files</Filter>
     </None>
@@ -3406,6 +3400,14 @@
     <None Include="..\..\scripts\update_version.py">
       <Filter>Tests\Scripts</Filter>
     </None>
+    <None Include="..\..\.github\workflows\clang-c++11.yml" />
+    <None Include="..\..\.github\workflows\clang-c++14.yml" />
+    <None Include="..\..\.github\workflows\clang-c++17.yml" />
+    <None Include="..\..\.github\workflows\clang-c++20.yml" />
+    <None Include="..\..\.github\workflows\gcc-c++11.yml" />
+    <None Include="..\..\.github\workflows\gcc-c++14.yml" />
+    <None Include="..\..\.github\workflows\gcc-c++17.yml" />
+    <None Include="..\..\.github\workflows\gcc-c++20.yml" />
   </ItemGroup>
   <ItemGroup>
     <Text Include="..\..\support\Release notes.txt">

From 3d3f87564dc964ea8f55d01175f75a1d9583d663 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Fri, 1 Dec 2023 17:21:48 +0000
Subject: [PATCH 03/26] Work in progress for etl::bitset::extract

---
 include/etl/private/bitset_new.h              | 186 +++++-----
 test/test_bitset_new_default_element_type.cpp | 326 +++++++++++++++++-
 ...itset_new_explicit_single_element_type.cpp |   4 +-
 ...st_bitset_new_ext_default_element_type.cpp |   4 +-
 ...t_new_ext_explicit_single_element_type.cpp |   4 +-
 5 files changed, 412 insertions(+), 112 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 058d8f45..4dbfbef8 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -145,6 +145,12 @@ namespace etl
     static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
     static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
 
+    template <size_t Position, size_t Length, size_t Bits_Per_Element>
+    struct value_is_in_one_element
+    {
+      static ETL_CONSTANT bool value = ((Position + Length - 1) >> etl::log2<Bits_Per_Element>::value) == (Position >> etl::log2<Bits_Per_Element>::value);
+    };
+
     //*************************************************************************
     /// Count the number of bits set.
     //*************************************************************************
@@ -400,63 +406,56 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    T extract_from_single_element(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
+    T extract_from_buffer(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
       unsigned_t value(0);
 
-      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
-      const int        element_index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
-      const unsigned_t Shift = position % Bits_Per_Element;
+      const int Msb_Element_Index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const int Lsb_Element_Index = position >> etl::log2<Bits_Per_Element>::value;
 
-      value = static_cast<unsigned_t>(pbuffer[element_index] >> Shift) & value_mask;
-
-      return static_cast<T>(value);
-    }
-
-    //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    T extract_from_multi_element(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
-    {
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      unsigned_t value(0);
-
-      // The mask for the value type.
-      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
-
-      // Find the index of the element containing the msb.
-      int element_index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
-
-      // The value is spread over multiple elements.       
-      element_type bit_mask = element_type(1) << ((position + length - 1) % Bits_Per_Element);
-
-      while (length != 0)
+      // Is the value contained within one element?
+      if (Msb_Element_Index == Lsb_Element_Index)
       {
-        // TODO Optimise this to read whole element values.
+        const unsigned_t Mask = ~(~0 << length);
+        const unsigned_t Shift = position % Bits_Per_Element;
 
-        value <<= 1;
+        value = static_cast<unsigned_t>(pbuffer[Msb_Element_Index] >> Shift) & Mask;
+      }
+      else
+      {
+        // Get the number of active bits in the msb element 
+        size_t active_bits_in_msb = (position + length) - (Msb_Element_Index * Bits_Per_Element);
 
-        const bool is_set = (pbuffer[element_index] & bit_mask) != 0;
+        // Extract the first element if partially filled.
+        // Start with index of the element containing the msb.
+        int element_index = Msb_Element_Index;
 
-        if (is_set)
+        if (active_bits_in_msb < Bits_Per_Element)
         {
-          value |= unsigned_t(1);
-        }
-
-        bit_mask >>= 1;
-
-        if (bit_mask == 0)
-        {
-          bit_mask = element_type(1) << (Bits_Per_Element - 1);
+          element_type mask = ~(~element_type(0) << active_bits_in_msb);
+          value |= pbuffer[element_index] & mask;
+          length -= active_bits_in_msb;
           --element_index;
         }
 
-        --length;
+        // Loop through the fully filled elements
+        while (length >= Bits_Per_Element)
+        {
+          value <<= Bits_Per_Element;
+          value |= pbuffer[element_index];
+          length -= Bits_Per_Element;
+          --element_index;
+        }
+
+        // Check if the last element is partially filled and extract.
+        if (length != 0)
+        {
+          value <<= length;
+          element_type mask = ~(~element_type(0) << length);
+          value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
+        }
       }
 
       return static_cast<T>(value);
@@ -467,17 +466,16 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
-    T extract_from_single_element(const_pointer pbuffer) const
+    typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, T>::type
+      extract_from_buffer(const_pointer pbuffer) const
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      unsigned_t value(0);
-
-      const unsigned_t value_mask    = etl::integral_limits<unsigned_t>::max;
-      const int        element_index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const int        Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const unsigned_t Mask          = ~(~0 << Length);
       const unsigned_t Shift         = Position % Bits_Per_Element;
-
-      value = static_cast<unsigned_t>(pbuffer[element_index] >> Shift) & value_mask;
+      
+      unsigned_t value = static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
 
       return static_cast<T>(value);
     }
@@ -487,44 +485,48 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
-    T extract_from_multi_element(const_pointer pbuffer) const
+    typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, T>::type
+      extract_from_buffer(const_pointer pbuffer) const
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
       unsigned_t value(0);
 
-      // The mask for the value type.
-      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
+      const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
 
-      // Find the index of the element containing the msb.
-      int element_index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+      // Start with index of the element containing the msb.
+      int element_index = Msb_Element_Index;
 
       // The value is spread over multiple elements.       
-      size_t       length   = Length;
-      element_type bit_mask = element_type(1) << ((Position + Length - 1) % Bits_Per_Element);
+      size_t length = Length;
 
-      while (length != 0)
+      // Get the number of active bits in the first element 
+      size_t active_bits_in_element = ((Position + Length - 1) % Bits_Per_Element) + 1;
+
+      // Extract the first element if partially filled.
+      if (active_bits_in_element < Bits_Per_Element)
       {
-        // TODO Optimise this to read whole element values.
+        element_type mask = ~(~element_type(0) << active_bits_in_element);
+        value |= pbuffer[element_index] & mask;
+        length -= active_bits_in_element;
+        --element_index;
+      }
 
-        value <<= 1;
+      // Loop through the fully filled elements
+      while (length >= Bits_Per_Element)
+      {
+        value <<= Bits_Per_Element;
+        value |= pbuffer[element_index];
+        length -= Bits_Per_Element;
+        --element_index;
+      }
 
-        const bool is_set = (pbuffer[element_index] & bit_mask) != 0;
-
-        if (is_set)
-        {
-          value |= unsigned_t(1);
-        }      
-
-        bit_mask >>= 1;
-
-        if (bit_mask == 0)
-        {
-          bit_mask = element_type(1) << (Bits_Per_Element - 1);
-          --element_index;
-        }
-
-        --length;
+      // Check if the last element is partially filled and extract.
+      if (length != 0)
+      {
+        value <<= length;
+        element_type mask = ~(~element_type(0) << length);
+        value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
       }
 
       return static_cast<T>(value);
@@ -2187,7 +2189,7 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
       value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
@@ -2206,7 +2208,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.extract_from_multi_element<T>(buffer, position, length);
+      return ibitset.extract_from_buffer<T>(buffer, position, length);
     }
 
     //*************************************************************************
@@ -2214,22 +2216,12 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
       extract() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      const int active_bits_in_element = ((Position + Length) % Bits_Per_Element);
-
-      // Is the value contained within one element?
-      if (active_bits_in_element == Length)
-      {
-        return ibitset.extract_from_single_element<T, Position, Length>(buffer);
-      }
-      else
-      {
-        return ibitset.extract_from_multi_element<T, Position, Length>(buffer);
-      }
+      return ibitset.extract_from_buffer<T, Position, Length>(buffer);
     }
 
     //*************************************************************************
@@ -3989,7 +3981,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.extract_from_multi_element<T>(pbuffer, position, length);
+      return ibitset.extract_from_buffer<T>(pbuffer, position, length);
     }
 
     //*************************************************************************
@@ -4002,17 +3994,7 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      const int active_bits_in_element = ((Position + Length) % Bits_Per_Element);
-
-      // Is the value contained within one element?
-      if (active_bits_in_element == Length)
-      {
-        return ibitset.extract_from_single_element<T, Position, Length>(pbuffer);
-      }
-      else
-      {
-        return ibitset.extract_from_multi_element<T, Position, Length>(pbuffer);
-      }
+      return ibitset.extract_from_buffer<T, Position, Length>(pbuffer);
     }
 
     //*************************************************************************
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index f41ac262..199e18a0 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -2098,7 +2098,82 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_run_time_parameters)
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint8_t_with_run_time_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
@@ -2128,11 +2203,12 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
       CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
       
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
       CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
 
     //*************************************************************************
-    TEST(test_extract_with_template_parameters)
+    TEST(test_extract_uint8_t_with_template_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
@@ -2163,8 +2239,250 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
 
       // The lines below should static assert.
-      //uint8_t v = b.extract<uint8_t, 25, 8>();
-      //uint8_t v = b.extract<uint8_t, 25, 9>();
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
+      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
+      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
+      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
+      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
+      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
+      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
+      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
+      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
+      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
+      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
+      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
+      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+
+      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 24, 9>();
+      //int8_t v2 = b.extract<int8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19,13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>(0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>(1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>(2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>(3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>(4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>(5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>(6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>(7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>(8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>(9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
+      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+
+      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t, 0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t, 1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t, 2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t, 3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t, 4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t, 5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t, 6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t, 7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t, 8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t, 9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //int16_t v1 = b.extract<int16_t, 16, 17>());
+      //int16_t v2 = b.extract<int16_t, 17, 16>());
     }
   };
 }
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index 0f25e6da..8e161389 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -1587,7 +1587,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_run_time_parameters)
+    TEST(test_extract_uint8_t_with_run_time_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
 
@@ -1620,7 +1620,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_template_parameters)
+    TEST(test_extract_uint8_t_with_template_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
 
diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp
index c5e12541..7e377a95 100644
--- a/test/test_bitset_new_ext_default_element_type.cpp
+++ b/test/test_bitset_new_ext_default_element_type.cpp
@@ -1959,7 +1959,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_run_time_parameters)
+    TEST(test_extract_uint8_t_with_run_time_parameters)
     {
       using bs32 = etl::bitset_ext<32>;
 
@@ -1994,7 +1994,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_template_parameters)
+    TEST(test_extract_uint8_t_with_template_parameters)
     {
       using bs32 = etl::bitset_ext<32>;
 
diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp
index 308259a4..d0b489be 100644
--- a/test/test_bitset_new_ext_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp
@@ -1311,7 +1311,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_run_time_parameters)
+    TEST(test_extract_uint8_t_with_run_time_parameters)
     {
       using bs32 = etl::bitset_ext<32, int32_t>;
 
@@ -1346,7 +1346,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_template_parameters)
+    TEST(test_extract_uint8_t_with_template_parameters)
     {
       using bs32 = etl::bitset_ext<32, int32_t>;
 

From 9064eecee2b11e2faab861856dd6d3497f1d9405 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Sat, 2 Dec 2023 17:46:38 +0000
Subject: [PATCH 04/26] Work in progress for etl::bitset::extract

---
 include/etl/private/bitset_new.h              | 148 ++++++++++--------
 test/test_bitset_new_default_element_type.cpp |  77 +++++++++
 test/vs2022/etl.vcxproj.filters               |  32 +++-
 3 files changed, 182 insertions(+), 75 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 4dbfbef8..65128c75 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -401,12 +401,62 @@ namespace etl
       return v;
     }
 
+    //*************************************************************************
+    /// Extract an value from multiple elements.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::make_unsigned<T>::type extract_from_multiple_elements(const element_type* pbuffer,
+                                                                        int                 element_index,
+                                                                        size_t              active_bits_in_msb,
+                                                                        size_t              length) const ETL_NOEXCEPT
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      // Extract the first element, if partially filled.
+      if (active_bits_in_msb < Bits_Per_Element)
+      {
+        element_type mask = ~(~element_type(0) << active_bits_in_msb);
+        value = pbuffer[element_index] & mask;
+        length -= active_bits_in_msb;
+        if (length >= Bits_Per_Element)
+        {
+          value = value << Bits_Per_Element;
+        }
+        --element_index;
+      }
+
+      // Loop through the fully filled elements
+      while (length >= Bits_Per_Element)
+      {
+        value |= pbuffer[element_index];
+        length -= Bits_Per_Element;
+        if (length >= Bits_Per_Element)
+        {
+          value = value << Bits_Per_Element;
+        }
+        --element_index;
+      }
+
+      // Extract the last element, if partially filled.
+      if (length != 0)
+      {
+        value = value << length;
+        element_type mask = ~(~element_type(0) << length);
+        value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
+      }
+
+      return value;
+    }
+
     //*************************************************************************
     /// Extract an integral value from an arbitary position and length.
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    T extract_from_buffer(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
+    typename etl::make_unsigned<T>::type extract_from_buffer(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
@@ -428,37 +478,13 @@ namespace etl
         // Get the number of active bits in the msb element 
         size_t active_bits_in_msb = (position + length) - (Msb_Element_Index * Bits_Per_Element);
 
-        // Extract the first element if partially filled.
         // Start with index of the element containing the msb.
         int element_index = Msb_Element_Index;
 
-        if (active_bits_in_msb < Bits_Per_Element)
-        {
-          element_type mask = ~(~element_type(0) << active_bits_in_msb);
-          value |= pbuffer[element_index] & mask;
-          length -= active_bits_in_msb;
-          --element_index;
-        }
-
-        // Loop through the fully filled elements
-        while (length >= Bits_Per_Element)
-        {
-          value <<= Bits_Per_Element;
-          value |= pbuffer[element_index];
-          length -= Bits_Per_Element;
-          --element_index;
-        }
-
-        // Check if the last element is partially filled and extract.
-        if (length != 0)
-        {
-          value <<= length;
-          element_type mask = ~(~element_type(0) << length);
-          value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
-        }
+        value = extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
       }
 
-      return static_cast<T>(value);
+      return value;
     }
 
     //*************************************************************************
@@ -466,7 +492,7 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
-    typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, T>::type
+    typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
       extract_from_buffer(const_pointer pbuffer) const
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
@@ -475,9 +501,7 @@ namespace etl
       const unsigned_t Mask          = ~(~0 << Length);
       const unsigned_t Shift         = Position % Bits_Per_Element;
       
-      unsigned_t value = static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
-
-      return static_cast<T>(value);
+      return  static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
     }
 
     //*************************************************************************
@@ -485,13 +509,11 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
-    typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, T>::type
+    typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
       extract_from_buffer(const_pointer pbuffer) const
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      unsigned_t value(0);
-
+       
       const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
 
       // Start with index of the element containing the msb.
@@ -501,35 +523,9 @@ namespace etl
       size_t length = Length;
 
       // Get the number of active bits in the first element 
-      size_t active_bits_in_element = ((Position + Length - 1) % Bits_Per_Element) + 1;
+      size_t active_bits_in_msb = ((Position + Length - 1) % Bits_Per_Element) + 1;
 
-      // Extract the first element if partially filled.
-      if (active_bits_in_element < Bits_Per_Element)
-      {
-        element_type mask = ~(~element_type(0) << active_bits_in_element);
-        value |= pbuffer[element_index] & mask;
-        length -= active_bits_in_element;
-        --element_index;
-      }
-
-      // Loop through the fully filled elements
-      while (length >= Bits_Per_Element)
-      {
-        value <<= Bits_Per_Element;
-        value |= pbuffer[element_index];
-        length -= Bits_Per_Element;
-        --element_index;
-      }
-
-      // Check if the last element is partially filled and extract.
-      if (length != 0)
-      {
-        value <<= length;
-        element_type mask = ~(~element_type(0) << length);
-        value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
-      }
-
-      return static_cast<T>(value);
+      return extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
     }
 
     //*************************************************************************
@@ -2208,7 +2204,16 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.extract_from_buffer<T>(buffer, position, length);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = ibitset.template extract_from_buffer<T>(buffer, position, length);;
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return value;
     }
 
     //*************************************************************************
@@ -2221,7 +2226,16 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      return ibitset.extract_from_buffer<T, Position, Length>(buffer);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = ibitset.template extract_from_buffer<T, Position, Length>(buffer);
+
+      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T, Length>(value);
+      }
+
+      return value;
     }
 
     //*************************************************************************
@@ -3981,7 +3995,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.extract_from_buffer<T>(pbuffer, position, length);
+      return ibitset.template extract_from_buffer<T>(pbuffer, position, length);
     }
 
     //*************************************************************************
@@ -3994,7 +4008,7 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      return ibitset.extract_from_buffer<T, Position, Length>(pbuffer);
+      return ibitset.template extract_from_buffer<T, Position, Length>(pbuffer);
     }
 
     //*************************************************************************
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index 199e18a0..a0980425 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -2172,6 +2172,83 @@ namespace
       //uint8_t v1 = b.extract<uint8_t, 27, 6>();
     }
 
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      auto v = b.extract<int8_t>(1, 6);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
     //*************************************************************************
     TEST(test_extract_uint8_t_with_run_time_parameters)
     {
diff --git a/test/vs2022/etl.vcxproj.filters b/test/vs2022/etl.vcxproj.filters
index cea19458..5430cd00 100644
--- a/test/vs2022/etl.vcxproj.filters
+++ b/test/vs2022/etl.vcxproj.filters
@@ -3400,14 +3400,30 @@
     <None Include="..\..\scripts\update_version.py">
       <Filter>Tests\Scripts</Filter>
     </None>
-    <None Include="..\..\.github\workflows\clang-c++11.yml" />
-    <None Include="..\..\.github\workflows\clang-c++14.yml" />
-    <None Include="..\..\.github\workflows\clang-c++17.yml" />
-    <None Include="..\..\.github\workflows\clang-c++20.yml" />
-    <None Include="..\..\.github\workflows\gcc-c++11.yml" />
-    <None Include="..\..\.github\workflows\gcc-c++14.yml" />
-    <None Include="..\..\.github\workflows\gcc-c++17.yml" />
-    <None Include="..\..\.github\workflows\gcc-c++20.yml" />
+    <None Include="..\..\.github\workflows\clang-c++11.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\clang-c++14.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\clang-c++17.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\clang-c++20.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++11.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++14.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++17.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++20.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <Text Include="..\..\support\Release notes.txt">

From 18a1c76ec67531e170e0e218db1f5bdc8d0a473e Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Sat, 2 Dec 2023 17:46:38 +0000
Subject: [PATCH 05/26] Work in progress for etl::bitset::extract

---
 include/etl/private/bitset_new.h              | 148 ++++++++++--------
 test/run-tests.sh                             |   2 +-
 test/test_bitset_new_default_element_type.cpp |  77 +++++++++
 test/vs2022/etl.vcxproj.filters               |  32 +++-
 4 files changed, 183 insertions(+), 76 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 4dbfbef8..65128c75 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -401,12 +401,62 @@ namespace etl
       return v;
     }
 
+    //*************************************************************************
+    /// Extract an value from multiple elements.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::make_unsigned<T>::type extract_from_multiple_elements(const element_type* pbuffer,
+                                                                        int                 element_index,
+                                                                        size_t              active_bits_in_msb,
+                                                                        size_t              length) const ETL_NOEXCEPT
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      // Extract the first element, if partially filled.
+      if (active_bits_in_msb < Bits_Per_Element)
+      {
+        element_type mask = ~(~element_type(0) << active_bits_in_msb);
+        value = pbuffer[element_index] & mask;
+        length -= active_bits_in_msb;
+        if (length >= Bits_Per_Element)
+        {
+          value = value << Bits_Per_Element;
+        }
+        --element_index;
+      }
+
+      // Loop through the fully filled elements
+      while (length >= Bits_Per_Element)
+      {
+        value |= pbuffer[element_index];
+        length -= Bits_Per_Element;
+        if (length >= Bits_Per_Element)
+        {
+          value = value << Bits_Per_Element;
+        }
+        --element_index;
+      }
+
+      // Extract the last element, if partially filled.
+      if (length != 0)
+      {
+        value = value << length;
+        element_type mask = ~(~element_type(0) << length);
+        value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
+      }
+
+      return value;
+    }
+
     //*************************************************************************
     /// Extract an integral value from an arbitary position and length.
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    T extract_from_buffer(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
+    typename etl::make_unsigned<T>::type extract_from_buffer(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
@@ -428,37 +478,13 @@ namespace etl
         // Get the number of active bits in the msb element 
         size_t active_bits_in_msb = (position + length) - (Msb_Element_Index * Bits_Per_Element);
 
-        // Extract the first element if partially filled.
         // Start with index of the element containing the msb.
         int element_index = Msb_Element_Index;
 
-        if (active_bits_in_msb < Bits_Per_Element)
-        {
-          element_type mask = ~(~element_type(0) << active_bits_in_msb);
-          value |= pbuffer[element_index] & mask;
-          length -= active_bits_in_msb;
-          --element_index;
-        }
-
-        // Loop through the fully filled elements
-        while (length >= Bits_Per_Element)
-        {
-          value <<= Bits_Per_Element;
-          value |= pbuffer[element_index];
-          length -= Bits_Per_Element;
-          --element_index;
-        }
-
-        // Check if the last element is partially filled and extract.
-        if (length != 0)
-        {
-          value <<= length;
-          element_type mask = ~(~element_type(0) << length);
-          value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
-        }
+        value = extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
       }
 
-      return static_cast<T>(value);
+      return value;
     }
 
     //*************************************************************************
@@ -466,7 +492,7 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
-    typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, T>::type
+    typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
       extract_from_buffer(const_pointer pbuffer) const
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
@@ -475,9 +501,7 @@ namespace etl
       const unsigned_t Mask          = ~(~0 << Length);
       const unsigned_t Shift         = Position % Bits_Per_Element;
       
-      unsigned_t value = static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
-
-      return static_cast<T>(value);
+      return  static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
     }
 
     //*************************************************************************
@@ -485,13 +509,11 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
-    typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, T>::type
+    typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
       extract_from_buffer(const_pointer pbuffer) const
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      unsigned_t value(0);
-
+       
       const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
 
       // Start with index of the element containing the msb.
@@ -501,35 +523,9 @@ namespace etl
       size_t length = Length;
 
       // Get the number of active bits in the first element 
-      size_t active_bits_in_element = ((Position + Length - 1) % Bits_Per_Element) + 1;
+      size_t active_bits_in_msb = ((Position + Length - 1) % Bits_Per_Element) + 1;
 
-      // Extract the first element if partially filled.
-      if (active_bits_in_element < Bits_Per_Element)
-      {
-        element_type mask = ~(~element_type(0) << active_bits_in_element);
-        value |= pbuffer[element_index] & mask;
-        length -= active_bits_in_element;
-        --element_index;
-      }
-
-      // Loop through the fully filled elements
-      while (length >= Bits_Per_Element)
-      {
-        value <<= Bits_Per_Element;
-        value |= pbuffer[element_index];
-        length -= Bits_Per_Element;
-        --element_index;
-      }
-
-      // Check if the last element is partially filled and extract.
-      if (length != 0)
-      {
-        value <<= length;
-        element_type mask = ~(~element_type(0) << length);
-        value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
-      }
-
-      return static_cast<T>(value);
+      return extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
     }
 
     //*************************************************************************
@@ -2208,7 +2204,16 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.extract_from_buffer<T>(buffer, position, length);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = ibitset.template extract_from_buffer<T>(buffer, position, length);;
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return value;
     }
 
     //*************************************************************************
@@ -2221,7 +2226,16 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      return ibitset.extract_from_buffer<T, Position, Length>(buffer);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = ibitset.template extract_from_buffer<T, Position, Length>(buffer);
+
+      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T, Length>(value);
+      }
+
+      return value;
     }
 
     //*************************************************************************
@@ -3981,7 +3995,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.extract_from_buffer<T>(pbuffer, position, length);
+      return ibitset.template extract_from_buffer<T>(pbuffer, position, length);
     }
 
     //*************************************************************************
@@ -3994,7 +4008,7 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      return ibitset.extract_from_buffer<T, Position, Length>(pbuffer);
+      return ibitset.template extract_from_buffer<T, Position, Length>(pbuffer);
     }
 
     //*************************************************************************
diff --git a/test/run-tests.sh b/test/run-tests.sh
index 90433c4e..0fa5d720 100644
--- a/test/run-tests.sh
+++ b/test/run-tests.sh
@@ -165,7 +165,7 @@ etl_version=$(echo $etl_version_raw | sed -e 's/\r//g') # Remove trailing \r
 # Get the compiler versions
 #******************************************************************************
 gcc_compiler=$(g++ --version | grep g++)
-clang_compiler=$(clang++ --version | grep clang++)
+clang_compiler=$(clang++ --version | grep clang)
 
 #******************************************************************************
 # GCC
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index 199e18a0..a0980425 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -2172,6 +2172,83 @@ namespace
       //uint8_t v1 = b.extract<uint8_t, 27, 6>();
     }
 
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      auto v = b.extract<int8_t>(1, 6);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
     //*************************************************************************
     TEST(test_extract_uint8_t_with_run_time_parameters)
     {
diff --git a/test/vs2022/etl.vcxproj.filters b/test/vs2022/etl.vcxproj.filters
index cea19458..5430cd00 100644
--- a/test/vs2022/etl.vcxproj.filters
+++ b/test/vs2022/etl.vcxproj.filters
@@ -3400,14 +3400,30 @@
     <None Include="..\..\scripts\update_version.py">
       <Filter>Tests\Scripts</Filter>
     </None>
-    <None Include="..\..\.github\workflows\clang-c++11.yml" />
-    <None Include="..\..\.github\workflows\clang-c++14.yml" />
-    <None Include="..\..\.github\workflows\clang-c++17.yml" />
-    <None Include="..\..\.github\workflows\clang-c++20.yml" />
-    <None Include="..\..\.github\workflows\gcc-c++11.yml" />
-    <None Include="..\..\.github\workflows\gcc-c++14.yml" />
-    <None Include="..\..\.github\workflows\gcc-c++17.yml" />
-    <None Include="..\..\.github\workflows\gcc-c++20.yml" />
+    <None Include="..\..\.github\workflows\clang-c++11.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\clang-c++14.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\clang-c++17.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\clang-c++20.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++11.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++14.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++17.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++20.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <Text Include="..\..\support\Release notes.txt">

From 5b4e991ee8f978bff79fb93825d92c4ad872695b Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Mon, 4 Dec 2023 08:37:10 +0000
Subject: [PATCH 06/26] Added additional etl::make_lsb_mask and
 etl::make_msb_mask binary functions

---
 include/etl/binary.h |  35 ++++++-
 test/test_binary.cpp | 218 +++++++++++++++++++++++++++++++++++--------
 2 files changed, 207 insertions(+), 46 deletions(-)

diff --git a/include/etl/binary.h b/include/etl/binary.h
index 1efd5f15..f6388562 100644
--- a/include/etl/binary.h
+++ b/include/etl/binary.h
@@ -2216,20 +2216,31 @@ namespace etl
   {
   public:
 
+    ETL_STATIC_ASSERT(NBits <= etl::integral_limits<T>::bits, "Mask exceeds type size");
+
     static ETL_CONSTANT T value = static_cast<T>(etl::max_value_for_nbits<NBits>::value);
   };
 
   template <typename T, size_t NBits>
   ETL_CONSTANT T lsb_mask<T, NBits>::value;
 
+  //***********************************
+  template <typename T, size_t NBits>
+  ETL_CONSTEXPR T make_lsb_mask()
+  {
+    ETL_STATIC_ASSERT(NBits <= etl::integral_limits<T>::bits, "Mask exceeds type size");
+
+    return lsb_mask<T, NBits>::value;
+  }
+
   //***********************************
   template <typename T>
-  ETL_CONSTEXPR14 T make_lsb_mask(size_t nbits)
+  ETL_CONSTEXPR T make_lsb_mask(size_t nbits)
   {
     typedef typename etl::make_unsigned<T>::type type;
 
-    return (nbits == etl::integral_limits<type>::bits) ? static_cast<T>(etl::integral_limits<type>::max)
-                                                       : static_cast<T>((static_cast<type>(1U) << nbits) - 1U);
+    return (nbits == 0U) ? static_cast<T>(0)
+      : static_cast<T>(static_cast<type>(~0) >> (etl::integral_limits<type>::bits - nbits));
   }
 
   //***********************************
@@ -2238,6 +2249,8 @@ namespace etl
   {
   public:
 
+    ETL_STATIC_ASSERT(NBits <= etl::integral_limits<T>::bits, "Mask exceeds type size");
+
     static ETL_CONSTANT T value = static_cast<T>(etl::reverse_bits_const<T, lsb_mask<T, NBits>::value>::value);
   };
 
@@ -2246,9 +2259,21 @@ namespace etl
 
   //***********************************
   template <typename T>
-  ETL_CONSTEXPR14 T make_msb_mask(size_t nbits)
+  ETL_CONSTEXPR T make_msb_mask(size_t nbits)
   {
-    return static_cast<T>(etl::reverse_bits(make_lsb_mask<T>(nbits)));
+    typedef typename etl::make_unsigned<T>::type type;
+
+    return (nbits == 0U) ? static_cast<T>(0)
+                         : static_cast<T>(static_cast<type>(~0) << (etl::integral_limits<type>::bits - nbits));
+  }
+
+  //***********************************
+  template <typename T, size_t NBits>
+  ETL_CONSTEXPR T make_msb_mask()
+  {
+    ETL_STATIC_ASSERT(NBits <= etl::integral_limits<T>::bits, "Mask exceeds type size");
+
+    return msb_mask<T, NBits>::value;
   }
 
   //***************************************************************************
diff --git a/test/test_binary.cpp b/test/test_binary.cpp
index 468758cd..56e5157d 100644
--- a/test/test_binary.cpp
+++ b/test/test_binary.cpp
@@ -2584,8 +2584,8 @@ namespace
     //*************************************************************************
     TEST(test_lsb_mask_64_bit)
     {
-      CHECK(int64_t(0x0000000000000000) == (etl::lsb_mask<int64_t, 0>::value));
-      CHECK(int64_t(0x00000000000000FF) == (etl::lsb_mask<int64_t, 8>::value));
+      CHECK(int64_t(0x0000000000000000) == (etl::lsb_mask<int64_t,  0>::value));
+      CHECK(int64_t(0x00000000000000FF) == (etl::lsb_mask<int64_t,  8>::value));
       CHECK(int64_t(0x000000000000FFFF) == (etl::lsb_mask<int64_t, 16>::value));
       CHECK(int64_t(0x0000000000FFFFFF) == (etl::lsb_mask<int64_t, 24>::value));
       CHECK(int64_t(0x00000000FFFFFFFF) == (etl::lsb_mask<int64_t, 32>::value));
@@ -2598,15 +2598,15 @@ namespace
     //*************************************************************************
     TEST(test_make_lsb_mask_8_bit)
     {
-      ETL_CONSTEXPR14 int8_t mask0 = etl::make_lsb_mask<int8_t>(0);
-      ETL_CONSTEXPR14 int8_t mask1 = etl::make_lsb_mask<int8_t>(1);
-      ETL_CONSTEXPR14 int8_t mask2 = etl::make_lsb_mask<int8_t>(2);
-      ETL_CONSTEXPR14 int8_t mask3 = etl::make_lsb_mask<int8_t>(3);
-      ETL_CONSTEXPR14 int8_t mask4 = etl::make_lsb_mask<int8_t>(4);
-      ETL_CONSTEXPR14 int8_t mask5 = etl::make_lsb_mask<int8_t>(5);
-      ETL_CONSTEXPR14 int8_t mask6 = etl::make_lsb_mask<int8_t>(6);
-      ETL_CONSTEXPR14 int8_t mask7 = etl::make_lsb_mask<int8_t>(7);
-      ETL_CONSTEXPR14 int8_t mask8 = etl::make_lsb_mask<int8_t>(8);
+      ETL_CONSTEXPR int8_t mask0 = etl::make_lsb_mask<int8_t>(0);
+      ETL_CONSTEXPR int8_t mask1 = etl::make_lsb_mask<int8_t>(1);
+      ETL_CONSTEXPR int8_t mask2 = etl::make_lsb_mask<int8_t>(2);
+      ETL_CONSTEXPR int8_t mask3 = etl::make_lsb_mask<int8_t>(3);
+      ETL_CONSTEXPR int8_t mask4 = etl::make_lsb_mask<int8_t>(4);
+      ETL_CONSTEXPR int8_t mask5 = etl::make_lsb_mask<int8_t>(5);
+      ETL_CONSTEXPR int8_t mask6 = etl::make_lsb_mask<int8_t>(6);
+      ETL_CONSTEXPR int8_t mask7 = etl::make_lsb_mask<int8_t>(7);
+      ETL_CONSTEXPR int8_t mask8 = etl::make_lsb_mask<int8_t>(8);
 
       CHECK(int8_t(etl::b00000000) == mask0);
       CHECK(int8_t(etl::b00000001) == mask1);
@@ -2629,18 +2629,52 @@ namespace
       CHECK(int8_t(etl::b11111111) == etl::make_lsb_mask<int8_t>(8));
     }
 
+    //*************************************************************************
+    TEST(test_make_lsb_mask_template_nbits_8_bit)
+    {
+      ETL_CONSTEXPR int8_t mask0 = etl::make_lsb_mask<int8_t, 0>();
+      ETL_CONSTEXPR int8_t mask1 = etl::make_lsb_mask<int8_t, 1>();
+      ETL_CONSTEXPR int8_t mask2 = etl::make_lsb_mask<int8_t, 2>();
+      ETL_CONSTEXPR int8_t mask3 = etl::make_lsb_mask<int8_t, 3>();
+      ETL_CONSTEXPR int8_t mask4 = etl::make_lsb_mask<int8_t, 4>();
+      ETL_CONSTEXPR int8_t mask5 = etl::make_lsb_mask<int8_t, 5>();
+      ETL_CONSTEXPR int8_t mask6 = etl::make_lsb_mask<int8_t, 6>();
+      ETL_CONSTEXPR int8_t mask7 = etl::make_lsb_mask<int8_t, 7>();
+      ETL_CONSTEXPR int8_t mask8 = etl::make_lsb_mask<int8_t, 8>();
+
+      CHECK(int8_t(etl::b00000000) == mask0);
+      CHECK(int8_t(etl::b00000001) == mask1);
+      CHECK(int8_t(etl::b00000011) == mask2);
+      CHECK(int8_t(etl::b00000111) == mask3);
+      CHECK(int8_t(etl::b00001111) == mask4);
+      CHECK(int8_t(etl::b00011111) == mask5);
+      CHECK(int8_t(etl::b00111111) == mask6);
+      CHECK(int8_t(etl::b01111111) == mask7);
+      CHECK(int8_t(etl::b11111111) == mask8);
+
+      CHECK(int8_t(etl::b00000000) == (etl::make_lsb_mask<int8_t, 0>()));
+      CHECK(int8_t(etl::b00000001) == (etl::make_lsb_mask<int8_t, 1>()));
+      CHECK(int8_t(etl::b00000011) == (etl::make_lsb_mask<int8_t, 2>()));
+      CHECK(int8_t(etl::b00000111) == (etl::make_lsb_mask<int8_t, 3>()));
+      CHECK(int8_t(etl::b00001111) == (etl::make_lsb_mask<int8_t, 4>()));
+      CHECK(int8_t(etl::b00011111) == (etl::make_lsb_mask<int8_t, 5>()));
+      CHECK(int8_t(etl::b00111111) == (etl::make_lsb_mask<int8_t, 6>()));
+      CHECK(int8_t(etl::b01111111) == (etl::make_lsb_mask<int8_t, 7>()));
+      CHECK(int8_t(etl::b11111111) == (etl::make_lsb_mask<int8_t, 8>()));
+    }
+
     //*************************************************************************
     TEST(test_make_lsb_mask_64_bit)
     {
-      ETL_CONSTEXPR14 int64_t mask0 = etl::make_lsb_mask<int64_t>(0);
-      ETL_CONSTEXPR14 int64_t mask1 = etl::make_lsb_mask<int64_t>(8);
-      ETL_CONSTEXPR14 int64_t mask2 = etl::make_lsb_mask<int64_t>(16);
-      ETL_CONSTEXPR14 int64_t mask3 = etl::make_lsb_mask<int64_t>(24);
-      ETL_CONSTEXPR14 int64_t mask4 = etl::make_lsb_mask<int64_t>(32);
-      ETL_CONSTEXPR14 int64_t mask5 = etl::make_lsb_mask<int64_t>(40);
-      ETL_CONSTEXPR14 int64_t mask6 = etl::make_lsb_mask<int64_t>(48);
-      ETL_CONSTEXPR14 int64_t mask7 = etl::make_lsb_mask<int64_t>(56);
-      ETL_CONSTEXPR14 int64_t mask8 = etl::make_lsb_mask<int64_t>(64);
+      ETL_CONSTEXPR int64_t mask0 = etl::make_lsb_mask<int64_t>(0);
+      ETL_CONSTEXPR int64_t mask1 = etl::make_lsb_mask<int64_t>(8);
+      ETL_CONSTEXPR int64_t mask2 = etl::make_lsb_mask<int64_t>(16);
+      ETL_CONSTEXPR int64_t mask3 = etl::make_lsb_mask<int64_t>(24);
+      ETL_CONSTEXPR int64_t mask4 = etl::make_lsb_mask<int64_t>(32);
+      ETL_CONSTEXPR int64_t mask5 = etl::make_lsb_mask<int64_t>(40);
+      ETL_CONSTEXPR int64_t mask6 = etl::make_lsb_mask<int64_t>(48);
+      ETL_CONSTEXPR int64_t mask7 = etl::make_lsb_mask<int64_t>(56);
+      ETL_CONSTEXPR int64_t mask8 = etl::make_lsb_mask<int64_t>(64);
 
       CHECK_EQUAL(int64_t(0x0000000000000000), mask0);
       CHECK_EQUAL(int64_t(0x00000000000000FF), mask1);
@@ -2664,7 +2698,41 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_msb_mask_8_bit_8_bit)
+    TEST(test_make_lsb_mask_template_nbits_64_bit)
+    {
+      ETL_CONSTEXPR int64_t mask0 = etl::make_lsb_mask<int64_t,  0>();
+      ETL_CONSTEXPR int64_t mask1 = etl::make_lsb_mask<int64_t,  8>();
+      ETL_CONSTEXPR int64_t mask2 = etl::make_lsb_mask<int64_t, 16>();
+      ETL_CONSTEXPR int64_t mask3 = etl::make_lsb_mask<int64_t, 24>();
+      ETL_CONSTEXPR int64_t mask4 = etl::make_lsb_mask<int64_t, 32>();
+      ETL_CONSTEXPR int64_t mask5 = etl::make_lsb_mask<int64_t, 40>();
+      ETL_CONSTEXPR int64_t mask6 = etl::make_lsb_mask<int64_t, 48>();
+      ETL_CONSTEXPR int64_t mask7 = etl::make_lsb_mask<int64_t, 56>();
+      ETL_CONSTEXPR int64_t mask8 = etl::make_lsb_mask<int64_t, 64>();
+
+      CHECK_EQUAL(int64_t(0x0000000000000000), mask0);
+      CHECK_EQUAL(int64_t(0x00000000000000FF), mask1);
+      CHECK_EQUAL(int64_t(0x000000000000FFFF), mask2);
+      CHECK_EQUAL(int64_t(0x0000000000FFFFFF), mask3);
+      CHECK_EQUAL(int64_t(0x00000000FFFFFFFF), mask4);
+      CHECK_EQUAL(int64_t(0x000000FFFFFFFFFF), mask5);
+      CHECK_EQUAL(int64_t(0x0000FFFFFFFFFFFF), mask6);
+      CHECK_EQUAL(int64_t(0x00FFFFFFFFFFFFFF), mask7);
+      CHECK_EQUAL(int64_t(0xFFFFFFFFFFFFFFFF), mask8);
+
+      CHECK_EQUAL(int64_t(0x0000000000000000), (etl::make_lsb_mask<int64_t,  0>()));
+      CHECK_EQUAL(int64_t(0x00000000000000FF), (etl::make_lsb_mask<int64_t,  8>()));
+      CHECK_EQUAL(int64_t(0x000000000000FFFF), (etl::make_lsb_mask<int64_t, 16>()));
+      CHECK_EQUAL(int64_t(0x0000000000FFFFFF), (etl::make_lsb_mask<int64_t, 24>()));
+      CHECK_EQUAL(int64_t(0x00000000FFFFFFFF), (etl::make_lsb_mask<int64_t, 32>()));
+      CHECK_EQUAL(int64_t(0x000000FFFFFFFFFF), (etl::make_lsb_mask<int64_t, 40>()));
+      CHECK_EQUAL(int64_t(0x0000FFFFFFFFFFFF), (etl::make_lsb_mask<int64_t, 48>()));
+      CHECK_EQUAL(int64_t(0x00FFFFFFFFFFFFFF), (etl::make_lsb_mask<int64_t, 56>()));
+      CHECK_EQUAL(int64_t(0xFFFFFFFFFFFFFFFF), (etl::make_lsb_mask<int64_t, 64>()));
+    }
+
+    //*************************************************************************
+    TEST(test_msb_mask_8_bit)
     {
       CHECK(int8_t(etl::b00000000) == (etl::msb_mask<int8_t, 0>::value));
       CHECK(int8_t(etl::b10000000) == (etl::msb_mask<int8_t, 1>::value));
@@ -2680,8 +2748,8 @@ namespace
     //*************************************************************************
     TEST(test_msb_mask_64_bit)
     {
-      CHECK(int64_t(0x0000000000000000) == (etl::msb_mask<int64_t, 0>::value));
-      CHECK(int64_t(0xFF00000000000000) == (etl::msb_mask<int64_t, 8>::value));
+      CHECK(int64_t(0x0000000000000000) == (etl::msb_mask<int64_t,  0>::value));
+      CHECK(int64_t(0xFF00000000000000) == (etl::msb_mask<int64_t,  8>::value));
       CHECK(int64_t(0xFFFF000000000000) == (etl::msb_mask<int64_t, 16>::value));
       CHECK(int64_t(0xFFFFFF0000000000) == (etl::msb_mask<int64_t, 24>::value));
       CHECK(int64_t(0xFFFFFFFF00000000) == (etl::msb_mask<int64_t, 32>::value));
@@ -2694,15 +2762,15 @@ namespace
     //*************************************************************************
     TEST(test_make_msb_mask_8_bit)
     {
-      ETL_CONSTEXPR14 int8_t mask0 = etl::make_msb_mask<int8_t>(0);
-      ETL_CONSTEXPR14 int8_t mask1 = etl::make_msb_mask<int8_t>(1);
-      ETL_CONSTEXPR14 int8_t mask2 = etl::make_msb_mask<int8_t>(2);
-      ETL_CONSTEXPR14 int8_t mask3 = etl::make_msb_mask<int8_t>(3);
-      ETL_CONSTEXPR14 int8_t mask4 = etl::make_msb_mask<int8_t>(4);
-      ETL_CONSTEXPR14 int8_t mask5 = etl::make_msb_mask<int8_t>(5);
-      ETL_CONSTEXPR14 int8_t mask6 = etl::make_msb_mask<int8_t>(6);
-      ETL_CONSTEXPR14 int8_t mask7 = etl::make_msb_mask<int8_t>(7);
-      ETL_CONSTEXPR14 int8_t mask8 = etl::make_msb_mask<int8_t>(8);
+      ETL_CONSTEXPR int8_t mask0 = etl::make_msb_mask<int8_t>(0);
+      ETL_CONSTEXPR int8_t mask1 = etl::make_msb_mask<int8_t>(1);
+      ETL_CONSTEXPR int8_t mask2 = etl::make_msb_mask<int8_t>(2);
+      ETL_CONSTEXPR int8_t mask3 = etl::make_msb_mask<int8_t>(3);
+      ETL_CONSTEXPR int8_t mask4 = etl::make_msb_mask<int8_t>(4);
+      ETL_CONSTEXPR int8_t mask5 = etl::make_msb_mask<int8_t>(5);
+      ETL_CONSTEXPR int8_t mask6 = etl::make_msb_mask<int8_t>(6);
+      ETL_CONSTEXPR int8_t mask7 = etl::make_msb_mask<int8_t>(7);
+      ETL_CONSTEXPR int8_t mask8 = etl::make_msb_mask<int8_t>(8);
 
       CHECK(int8_t(etl::b00000000) == mask0);
       CHECK(int8_t(etl::b10000000) == mask1);
@@ -2725,18 +2793,52 @@ namespace
       CHECK(int8_t(etl::b11111111) == etl::make_msb_mask<int8_t>(8));
     }
 
+    //*************************************************************************
+    TEST(test_make_msb_mask_template_nbits_8_bit)
+    {
+      ETL_CONSTEXPR int8_t mask0 = etl::make_msb_mask<int8_t, 0>();
+      ETL_CONSTEXPR int8_t mask1 = etl::make_msb_mask<int8_t, 1>();
+      ETL_CONSTEXPR int8_t mask2 = etl::make_msb_mask<int8_t, 2>();
+      ETL_CONSTEXPR int8_t mask3 = etl::make_msb_mask<int8_t, 3>();
+      ETL_CONSTEXPR int8_t mask4 = etl::make_msb_mask<int8_t, 4>();
+      ETL_CONSTEXPR int8_t mask5 = etl::make_msb_mask<int8_t, 5>();
+      ETL_CONSTEXPR int8_t mask6 = etl::make_msb_mask<int8_t, 6>();
+      ETL_CONSTEXPR int8_t mask7 = etl::make_msb_mask<int8_t, 7>();
+      ETL_CONSTEXPR int8_t mask8 = etl::make_msb_mask<int8_t, 8>();
+
+      CHECK(int8_t(etl::b00000000) == mask0);
+      CHECK(int8_t(etl::b10000000) == mask1);
+      CHECK(int8_t(etl::b11000000) == mask2);
+      CHECK(int8_t(etl::b11100000) == mask3);
+      CHECK(int8_t(etl::b11110000) == mask4);
+      CHECK(int8_t(etl::b11111000) == mask5);
+      CHECK(int8_t(etl::b11111100) == mask6);
+      CHECK(int8_t(etl::b11111110) == mask7);
+      CHECK(int8_t(etl::b11111111) == mask8);
+
+      CHECK(int8_t(etl::b00000000) == (etl::make_msb_mask<int8_t, 0>()));
+      CHECK(int8_t(etl::b10000000) == (etl::make_msb_mask<int8_t, 1>()));
+      CHECK(int8_t(etl::b11000000) == (etl::make_msb_mask<int8_t, 2>()));
+      CHECK(int8_t(etl::b11100000) == (etl::make_msb_mask<int8_t, 3>()));
+      CHECK(int8_t(etl::b11110000) == (etl::make_msb_mask<int8_t, 4>()));
+      CHECK(int8_t(etl::b11111000) == (etl::make_msb_mask<int8_t, 5>()));
+      CHECK(int8_t(etl::b11111100) == (etl::make_msb_mask<int8_t, 6>()));
+      CHECK(int8_t(etl::b11111110) == (etl::make_msb_mask<int8_t, 7>()));
+      CHECK(int8_t(etl::b11111111) == (etl::make_msb_mask<int8_t, 8>()));
+    }
+
     //*************************************************************************
     TEST(test_make_msb_mask_64_bit)
     {
-      ETL_CONSTEXPR14 int64_t mask0 = etl::make_msb_mask<int64_t>(0);
-      ETL_CONSTEXPR14 int64_t mask1 = etl::make_msb_mask<int64_t>(8);
-      ETL_CONSTEXPR14 int64_t mask2 = etl::make_msb_mask<int64_t>(16);
-      ETL_CONSTEXPR14 int64_t mask3 = etl::make_msb_mask<int64_t>(24);
-      ETL_CONSTEXPR14 int64_t mask4 = etl::make_msb_mask<int64_t>(32);
-      ETL_CONSTEXPR14 int64_t mask5 = etl::make_msb_mask<int64_t>(40);
-      ETL_CONSTEXPR14 int64_t mask6 = etl::make_msb_mask<int64_t>(48);
-      ETL_CONSTEXPR14 int64_t mask7 = etl::make_msb_mask<int64_t>(56);
-      ETL_CONSTEXPR14 int64_t mask8 = etl::make_msb_mask<int64_t>(64);
+      ETL_CONSTEXPR int64_t mask0 = etl::make_msb_mask<int64_t>(0);
+      ETL_CONSTEXPR int64_t mask1 = etl::make_msb_mask<int64_t>(8);
+      ETL_CONSTEXPR int64_t mask2 = etl::make_msb_mask<int64_t>(16);
+      ETL_CONSTEXPR int64_t mask3 = etl::make_msb_mask<int64_t>(24);
+      ETL_CONSTEXPR int64_t mask4 = etl::make_msb_mask<int64_t>(32);
+      ETL_CONSTEXPR int64_t mask5 = etl::make_msb_mask<int64_t>(40);
+      ETL_CONSTEXPR int64_t mask6 = etl::make_msb_mask<int64_t>(48);
+      ETL_CONSTEXPR int64_t mask7 = etl::make_msb_mask<int64_t>(56);
+      ETL_CONSTEXPR int64_t mask8 = etl::make_msb_mask<int64_t>(64);
 
       CHECK_EQUAL(int64_t(0x0000000000000000), mask0);
       CHECK_EQUAL(int64_t(0xFF00000000000000), mask1);
@@ -2758,6 +2860,40 @@ namespace
       CHECK_EQUAL(int64_t(0xFFFFFFFFFFFFFF00), etl::make_msb_mask<int64_t>(56));
       CHECK_EQUAL(int64_t(0xFFFFFFFFFFFFFFFF), etl::make_msb_mask<int64_t>(64));
     }
+
+    //*************************************************************************
+    TEST(test_make_msb_mask_template_nbits_64_bit)
+    {
+      ETL_CONSTEXPR int64_t mask0 = etl::make_msb_mask<int64_t,  0>();
+      ETL_CONSTEXPR int64_t mask1 = etl::make_msb_mask<int64_t,  8>();
+      ETL_CONSTEXPR int64_t mask2 = etl::make_msb_mask<int64_t, 16>();
+      ETL_CONSTEXPR int64_t mask3 = etl::make_msb_mask<int64_t, 24>();
+      ETL_CONSTEXPR int64_t mask4 = etl::make_msb_mask<int64_t, 32>();
+      ETL_CONSTEXPR int64_t mask5 = etl::make_msb_mask<int64_t, 40>();
+      ETL_CONSTEXPR int64_t mask6 = etl::make_msb_mask<int64_t, 48>();
+      ETL_CONSTEXPR int64_t mask7 = etl::make_msb_mask<int64_t, 56>();
+      ETL_CONSTEXPR int64_t mask8 = etl::make_msb_mask<int64_t, 64>();
+
+      CHECK_EQUAL(int64_t(0x0000000000000000), mask0);
+      CHECK_EQUAL(int64_t(0xFF00000000000000), mask1);
+      CHECK_EQUAL(int64_t(0xFFFF000000000000), mask2);
+      CHECK_EQUAL(int64_t(0xFFFFFF0000000000), mask3);
+      CHECK_EQUAL(int64_t(0xFFFFFFFF00000000), mask4);
+      CHECK_EQUAL(int64_t(0xFFFFFFFFFF000000), mask5);
+      CHECK_EQUAL(int64_t(0xFFFFFFFFFFFF0000), mask6);
+      CHECK_EQUAL(int64_t(0xFFFFFFFFFFFFFF00), mask7);
+      CHECK_EQUAL(int64_t(0xFFFFFFFFFFFFFFFF), mask8);
+
+      CHECK_EQUAL(int64_t(0x0000000000000000), (etl::make_msb_mask<int64_t,  0>()));
+      CHECK_EQUAL(int64_t(0xFF00000000000000), (etl::make_msb_mask<int64_t,  8>()));
+      CHECK_EQUAL(int64_t(0xFFFF000000000000), (etl::make_msb_mask<int64_t, 16>()));
+      CHECK_EQUAL(int64_t(0xFFFFFF0000000000), (etl::make_msb_mask<int64_t, 24>()));
+      CHECK_EQUAL(int64_t(0xFFFFFFFF00000000), (etl::make_msb_mask<int64_t, 32>()));
+      CHECK_EQUAL(int64_t(0xFFFFFFFFFF000000), (etl::make_msb_mask<int64_t, 40>()));
+      CHECK_EQUAL(int64_t(0xFFFFFFFFFFFF0000), (etl::make_msb_mask<int64_t, 48>()));
+      CHECK_EQUAL(int64_t(0xFFFFFFFFFFFFFF00), (etl::make_msb_mask<int64_t, 56>()));
+      CHECK_EQUAL(int64_t(0xFFFFFFFFFFFFFFFF), (etl::make_msb_mask<int64_t, 64>()));
+    }
   };
 }
 

From 11491333844ef7a7b39e1e047a9793a94040881a Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Mon, 4 Dec 2023 08:37:42 +0000
Subject: [PATCH 07/26] Updated script text

---
 test/run-syntax-checks.sh | 2 +-
 test/run-tests.sh         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/run-syntax-checks.sh b/test/run-syntax-checks.sh
index 76b5a7eb..2e62336e 100644
--- a/test/run-syntax-checks.sh
+++ b/test/run-syntax-checks.sh
@@ -32,7 +32,7 @@ PrintHeader()
 	echo " Configuration     : $configuration_name                                    " | tee -a log.txt
 	echo " Compiler          : $compiler                                              " | tee -a log.txt
 	echo " Language standard : C++$cxx_standard                                       " | tee -a log.txt
-	echo " ETL Version       : $etl_version                                           " | tee -a log.txt
+	echo " ETL version       : $etl_version                                           " | tee -a log.txt
 	echo " Git branch        : $(ParseGitBranch)                                      " | tee -a log.txt
 	echo " Processes         : ${CMAKE_BUILD_PARALLEL_LEVEL}                          " | tee -a log.txt
 	echo "============================================================================" | tee -a log.txt
diff --git a/test/run-tests.sh b/test/run-tests.sh
index 0fa5d720..956d9838 100644
--- a/test/run-tests.sh
+++ b/test/run-tests.sh
@@ -43,7 +43,7 @@ PrintHeader()
 	echo " Language standard : C++$cxx_standard                                       " | tee -a log.txt
     echo " Optimisation      : $opt                                                   " | tee -a log.txt
 	echo " Sanitizer         : $sanitize                                              " | tee -a log.txt
-	echo " ETL Version       : $etl_version                                           " | tee -a log.txt
+	echo " ETL version       : $etl_version                                           " | tee -a log.txt
 	echo " Git branch        : $(ParseGitBranch)                                      " | tee -a log.txt
 	echo " Processes         : ${CMAKE_BUILD_PARALLEL_LEVEL}                          " | tee -a log.txt
 	echo "============================================================================" | tee -a log.txt

From 305f34fbede50ffa2927c198ca27da6b230a66ba Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Mon, 4 Dec 2023 08:37:59 +0000
Subject: [PATCH 08/26] Work in progress for etl::bitset::extract

---
 include/etl/private/bitset_new.h              | 100 +++-
 test/test_bitset_new_default_element_type.cpp |  82 ++-
 ...itset_new_explicit_single_element_type.cpp | 498 ++++++++++++++++--
 ...st_bitset_new_ext_default_element_type.cpp | 437 ++++++++++++++-
 ...t_new_ext_explicit_single_element_type.cpp | 441 +++++++++++++++-
 5 files changed, 1432 insertions(+), 126 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 65128c75..6894feb9 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -418,7 +418,7 @@ namespace etl
       // Extract the first element, if partially filled.
       if (active_bits_in_msb < Bits_Per_Element)
       {
-        element_type mask = ~(~element_type(0) << active_bits_in_msb);
+        element_type mask = etl::make_lsb_mask< element_type>(active_bits_in_msb);
         value = pbuffer[element_index] & mask;
         length -= active_bits_in_msb;
         if (length >= Bits_Per_Element)
@@ -444,7 +444,7 @@ namespace etl
       if (length != 0)
       {
         value = value << length;
-        element_type mask = ~(~element_type(0) << length);
+        element_type mask = etl::make_lsb_mask< element_type>(length);
         value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
       }
 
@@ -468,7 +468,7 @@ namespace etl
       // Is the value contained within one element?
       if (Msb_Element_Index == Lsb_Element_Index)
       {
-        const unsigned_t Mask = ~(~0 << length);
+        const unsigned_t Mask  = etl::make_lsb_mask< unsigned_t>(length);
         const unsigned_t Shift = position % Bits_Per_Element;
 
         value = static_cast<unsigned_t>(pbuffer[Msb_Element_Index] >> Shift) & Mask;
@@ -498,7 +498,7 @@ namespace etl
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
       const int        Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
-      const unsigned_t Mask          = ~(~0 << Length);
+      const unsigned_t Mask          = etl::lsb_mask<unsigned_t, Length>::value;
       const unsigned_t Shift         = Position % Bits_Per_Element;
       
       return  static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
@@ -511,9 +511,7 @@ namespace etl
     ETL_CONSTEXPR14
     typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
       extract_from_buffer(const_pointer pbuffer) const
-    {
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
-       
+    {      
       const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
 
       // Start with index of the element containing the msb.
@@ -978,7 +976,7 @@ namespace etl
   /// Specialisation that uses a single element if the element type is the 
   /// same size as the number of active bits.
   //***************************************************************************
-  template <size_t   Active_Bits, typename TElement>
+  template <size_t Active_Bits, typename TElement>
   class bitset<Active_Bits, TElement, true> : public bitset_constants<>
   {
   public:
@@ -1413,10 +1411,19 @@ namespace etl
       ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
 
-      element_type mask = (~(~0u << length) << position);
-      T value((buffer & mask) >> position);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      return value;
+      const unsigned_t Mask  = etl::make_lsb_mask< unsigned_t>(length);
+      const unsigned_t Shift = position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(buffer >> Shift) & Mask;
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -1430,10 +1437,19 @@ namespace etl
       ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
       
-      element_type mask = (~(~0u << Length) << Position);
-      T value((buffer & mask) >> Position);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      return value;
+      const unsigned_t Mask  = etl::make_lsb_mask<unsigned_t, Length>();
+      const unsigned_t Shift = Position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(buffer >> Shift) & Mask;
+
+      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T, Length>(value);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -2213,7 +2229,7 @@ namespace etl
         value = etl::sign_extend<T>(value, length);
       }
 
-      return value;
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -2235,7 +2251,7 @@ namespace etl
         value = etl::sign_extend<T, Length>(value);
       }
 
-      return value;
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -3202,10 +3218,19 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      element_type mask = (~(~0u << length) << position);
-      T v((*pbuffer & mask) >> position);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      return v;
+      const unsigned_t Mask = etl::make_lsb_mask<unsigned_t>(length);
+      const unsigned_t Shift = position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -3218,10 +3243,19 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      element_type mask = (~(~0u << Length) << Position);
-      T v((*pbuffer & mask) >> Position);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      return v;
+      const unsigned_t Mask = etl::make_lsb_mask<unsigned_t, Length>();
+      const unsigned_t Shift = Position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
+
+      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T, Length>(value);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -3995,7 +4029,16 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.template extract_from_buffer<T>(pbuffer, position, length);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = ibitset.template extract_from_buffer<T>(pbuffer, position, length);
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -4008,7 +4051,16 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      return ibitset.template extract_from_buffer<T, Position, Length>(pbuffer);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = ibitset.template extract_from_buffer<T, Position, Length>(pbuffer);
+
+      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T, Length>(value);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index a0980425..266243f7 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -2177,18 +2177,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      auto v = b.extract<int8_t>(1, 6);
-
-      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
       CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
       CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
@@ -2216,16 +2214,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
@@ -2512,16 +2510,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>(0, 16));
-      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>(1, 16));
-      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>(2, 16));
-      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>(3, 16));
-      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>(4, 16));
-      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>(5, 16));
-      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>(6, 16));
-      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>(7, 16));
-      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>(8, 16));
-      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>(9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
       CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
       CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
       CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
@@ -2539,16 +2537,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t, 0, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t, 1, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t, 2, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t, 3, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t, 4, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t, 5, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t, 6, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t, 7, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t, 8, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t, 9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
       CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
       CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
       CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index 8e161389..ad8f8fe1 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -1586,36 +1586,188 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
 
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
     //*************************************************************************
     TEST(test_extract_uint8_t_with_run_time_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
 
-      CHECK_EQUAL(0x78, b.extract<uint8_t>(0, 8));
-      CHECK_EQUAL(0x3C, b.extract<uint8_t>(1, 8));
-      CHECK_EQUAL(0x9E, b.extract<uint8_t>(2, 8));
-      CHECK_EQUAL(0xCF, b.extract<uint8_t>(3, 8));
-      CHECK_EQUAL(0x67, b.extract<uint8_t>(4, 8));
-      CHECK_EQUAL(0xB3, b.extract<uint8_t>(5, 8));
-      CHECK_EQUAL(0x59, b.extract<uint8_t>(6, 8));
-      CHECK_EQUAL(0xAC, b.extract<uint8_t>(7, 8));
-      CHECK_EQUAL(0x56, b.extract<uint8_t>(8, 8));
-      CHECK_EQUAL(0x2B, b.extract<uint8_t>(9, 8));
-      CHECK_EQUAL(0x15, b.extract<uint8_t>(10, 8));
-      CHECK_EQUAL(0x8A, b.extract<uint8_t>(11, 8));
-      CHECK_EQUAL(0x45, b.extract<uint8_t>(12, 8));
-      CHECK_EQUAL(0xA2, b.extract<uint8_t>(13, 8));
-      CHECK_EQUAL(0xD1, b.extract<uint8_t>(14, 8));
-      CHECK_EQUAL(0x68, b.extract<uint8_t>(15, 8));
-      CHECK_EQUAL(0x34, b.extract<uint8_t>(16, 8));
-      CHECK_EQUAL(0x1A, b.extract<uint8_t>(17, 8));
-      CHECK_EQUAL(0x8D, b.extract<uint8_t>(18, 8));
-      CHECK_EQUAL(0x46, b.extract<uint8_t>(19, 8));
-      CHECK_EQUAL(0x23, b.extract<uint8_t>(20, 8));
-      CHECK_EQUAL(0x91, b.extract<uint8_t>(21, 8));
-      CHECK_EQUAL(0x48, b.extract<uint8_t>(22, 8));
-      CHECK_EQUAL(0x24, b.extract<uint8_t>(23, 8));
-      CHECK_EQUAL(0x12, b.extract<uint8_t>(24, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
       CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
 
@@ -1624,35 +1776,277 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
 
-      CHECK_EQUAL(0x78, (b.extract<uint8_t, 0, 8>()));
-      CHECK_EQUAL(0x3C, (b.extract<uint8_t, 1, 8>()));
-      CHECK_EQUAL(0x9E, (b.extract<uint8_t, 2, 8>()));
-      CHECK_EQUAL(0xCF, (b.extract<uint8_t, 3, 8>()));
-      CHECK_EQUAL(0x67, (b.extract<uint8_t, 4, 8>()));
-      CHECK_EQUAL(0xB3, (b.extract<uint8_t, 5, 8>()));
-      CHECK_EQUAL(0x59, (b.extract<uint8_t, 6, 8>()));
-      CHECK_EQUAL(0xAC, (b.extract<uint8_t, 7, 8>()));
-      CHECK_EQUAL(0x56, (b.extract<uint8_t, 8, 8>()));
-      CHECK_EQUAL(0x2B, (b.extract<uint8_t, 9, 8>()));
-      CHECK_EQUAL(0x15, (b.extract<uint8_t, 10, 8>()));
-      CHECK_EQUAL(0x8A, (b.extract<uint8_t, 11, 8>()));
-      CHECK_EQUAL(0x45, (b.extract<uint8_t, 12, 8>()));
-      CHECK_EQUAL(0xA2, (b.extract<uint8_t, 13, 8>()));
-      CHECK_EQUAL(0xD1, (b.extract<uint8_t, 14, 8>()));
-      CHECK_EQUAL(0x68, (b.extract<uint8_t, 15, 8>()));
-      CHECK_EQUAL(0x34, (b.extract<uint8_t, 16, 8>()));
-      CHECK_EQUAL(0x1A, (b.extract<uint8_t, 17, 8>()));
-      CHECK_EQUAL(0x8D, (b.extract<uint8_t, 18, 8>()));
-      CHECK_EQUAL(0x46, (b.extract<uint8_t, 19, 8>()));
-      CHECK_EQUAL(0x23, (b.extract<uint8_t, 20, 8>()));
-      CHECK_EQUAL(0x91, (b.extract<uint8_t, 21, 8>()));
-      CHECK_EQUAL(0x48, (b.extract<uint8_t, 22, 8>()));
-      CHECK_EQUAL(0x24, (b.extract<uint8_t, 23, 8>()));
-      CHECK_EQUAL(0x12, (b.extract<uint8_t, 24, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
 
       // The lines below should static assert.
-      //uint8_t v = b.extract<uint8_t, 25, 8>();
-      //uint8_t v = b.extract<uint8_t, 25, 9>();
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
+      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
+      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
+      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
+      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
+      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
+      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
+      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
+      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
+      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
+      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
+      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
+      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+
+      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 24, 9>();
+      //int8_t v2 = b.extract<int8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
+      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+
+      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //int16_t v1 = b.extract<int16_t, 16, 17>());
+      //int16_t v2 = b.extract<int16_t, 17, 16>());
     }
   };
 }
diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp
index 7e377a95..201e98e6 100644
--- a/test/test_bitset_new_ext_default_element_type.cpp
+++ b/test/test_bitset_new_ext_default_element_type.cpp
@@ -1958,6 +1958,168 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
 
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
     //*************************************************************************
     TEST(test_extract_uint8_t_with_run_time_parameters)
     {
@@ -1991,6 +2153,9 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
       CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
       CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
 
     //*************************************************************************
@@ -2027,9 +2192,275 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
       CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
 
-      // The line below should static assert.
-      //uint8_t v = b.extract<uint8_t, 25, 8>();
-      //uint8_t v = b.extract<uint8_t, 25, 9>();
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
+      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
+      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
+      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
+      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
+      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
+      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
+      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
+      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
+      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
+      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
+      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
+      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+
+      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 24, 9>();
+      //int8_t v2 = b.extract<int8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
+      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+
+      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //int16_t v1 = b.extract<int16_t, 16, 17>());
+      //int16_t v2 = b.extract<int16_t, 17, 16>());
     }
   };
 }
diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp
index d0b489be..163d1865 100644
--- a/test/test_bitset_new_ext_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp
@@ -1310,10 +1310,172 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
 
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
     //*************************************************************************
     TEST(test_extract_uint8_t_with_run_time_parameters)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
@@ -1343,12 +1505,15 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
       CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
       CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
 
     //*************************************************************************
     TEST(test_extract_uint8_t_with_template_parameters)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
@@ -1379,9 +1544,275 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
       CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
 
-      // The line below should static assert.
-      //uint8_t v = b.extract<uint8_t, 25, 8>();
-      //uint8_t v = b.extract<uint8_t, 25, 9>();
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
+      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
+      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
+      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
+      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
+      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
+      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
+      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
+      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
+      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
+      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
+      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
+      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+
+      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 24, 9>();
+      //int8_t v2 = b.extract<int8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
+      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+
+      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //int16_t v1 = b.extract<int16_t, 16, 17>());
+      //int16_t v2 = b.extract<int16_t, 17, 16>());
     }
   };
 }

From 6d941298ea5a412aff43a85e76f152979db6aa1f Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Wed, 29 Nov 2023 18:21:47 +0000
Subject: [PATCH 09/26] Improved display of CHECK_EQUAL_HEX in unittest++

---
 test/UnitTest++/Checks.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/test/UnitTest++/Checks.h b/test/UnitTest++/Checks.h
index a2571e02..88f1a1c3 100644
--- a/test/UnitTest++/Checks.h
+++ b/test/UnitTest++/Checks.h
@@ -190,7 +190,9 @@ namespace UnitTest
      if (!(expected == actual))
      {
        UnitTest::MemoryOutStream stream;
-       stream << std::hex << std::uppercase << std::setfill('0') << "Expected 0x" << std::setw(2 * sizeof(Expected)) << expected << " but was 0x" << std::setw(2 * sizeof(Actual)) << actual;
+       stream << std::hex << std::uppercase << std::setfill('0') 
+              << "Expected 0x" << std::setw(2 * sizeof(Expected)) << (expected & ~(typename std::make_unsigned<Expected>::type(0))) 
+              << " but was 0x" << std::setw(2 * sizeof(Actual))   << (actual   & ~(typename std::make_unsigned<Actual>::type(0)));
 
        results.OnTestFailure(details, stream.GetText());
      }
@@ -214,7 +216,8 @@ namespace UnitTest
      if (expected == actual)
      {
        UnitTest::MemoryOutStream stream;
-       stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2 * sizeof(Actual)) << "Expected not equal, but both values are " << actual;
+       stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2 * sizeof(Actual)) 
+              << "Expected not equal, but both values are " << (actual & ~(typename std::make_unsigned<Actual>::type(0)));
 
        results.OnTestFailure(details, stream.GetText());
      }

From a5b425f03e310c98905dc500eaaf1d43ada15d47 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Wed, 29 Nov 2023 18:22:34 +0000
Subject: [PATCH 10/26] Work in progress for etl::bitset::extract

---
 include/etl/private/bitset_new.h              | 307 +++++++++++++++++-
 test/test_bitset_new_default_element_type.cpp |  70 ++++
 ...itset_new_explicit_single_element_type.cpp |  69 ++++
 ...st_bitset_new_ext_default_element_type.cpp |  74 +++++
 ...t_new_ext_explicit_single_element_type.cpp |  74 +++++
 test/vs2022/etl.vcxproj                       |  22 +-
 6 files changed, 588 insertions(+), 28 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 2887c97d..530f5c6a 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -206,7 +206,7 @@ namespace etl
       size_t    index = 0;
       element_type bit = 0;
 
-      if (number_of_elements == 0)
+      if (number_of_elements == 0) ETL_UNLIKELY
       {
         return;
       }
@@ -243,12 +243,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -273,12 +273,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -303,12 +303,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -333,12 +333,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -409,6 +409,141 @@ namespace etl
       return v;
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    T extract_from_single_element(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
+      const int        element_index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const unsigned_t Shift = position % Bits_Per_Element;
+
+      value = static_cast<unsigned_t>(pbuffer[element_index] >> Shift) & value_mask;
+
+      return static_cast<T>(value);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    T extract_from_multi_element(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      // The mask for the value type.
+      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
+
+      // Find the index of the element containing the msb.
+      int element_index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
+
+      // The value is spread over multiple elements.       
+      element_type bit_mask = element_type(1) << ((position + length - 1) % Bits_Per_Element);
+
+      while (length != 0)
+      {
+        // TODO Optimise this to read whole element values.
+
+        value <<= 1;
+
+        const bool is_set = (pbuffer[element_index] & bit_mask) != 0;
+
+        if (is_set)
+        {
+          value |= unsigned_t(1);
+        }
+
+        bit_mask >>= 1;
+
+        if (bit_mask == 0)
+        {
+          bit_mask = element_type(1) << (Bits_Per_Element - 1);
+          --element_index;
+        }
+
+        --length;
+      }
+
+      return static_cast<T>(value);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length>
+    ETL_CONSTEXPR14
+    T extract_from_single_element(const_pointer pbuffer) const
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      const unsigned_t value_mask    = etl::integral_limits<unsigned_t>::max;
+      const int        element_index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const unsigned_t Shift         = Position % Bits_Per_Element;
+
+      value = static_cast<unsigned_t>(pbuffer[element_index] >> Shift) & value_mask;
+
+      return static_cast<T>(value);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length>
+    ETL_CONSTEXPR14
+    T extract_from_multi_element(const_pointer pbuffer) const
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      // The mask for the value type.
+      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
+
+      // Find the index of the element containing the msb.
+      int element_index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+
+      // The value is spread over multiple elements.       
+      size_t       length   = Length;
+      element_type bit_mask = element_type(1) << ((Position + Length - 1) % Bits_Per_Element);
+
+      while (length != 0)
+      {
+        // TODO Optimise this to read whole element values.
+
+        value <<= 1;
+
+        const bool is_set = (pbuffer[element_index] & bit_mask) != 0;
+
+        if (is_set)
+        {
+          value |= unsigned_t(1);
+        }      
+
+        bit_mask >>= 1;
+
+        if (bit_mask == 0)
+        {
+          bit_mask = element_type(1) << (Bits_Per_Element - 1);
+          --element_index;
+        }
+
+        --length;
+      }
+
+      return static_cast<T>(value);
+    }
+
     //*************************************************************************
     /// Reset the bit at the position.
     //*************************************************************************
@@ -417,7 +552,7 @@ namespace etl
       size_t       index = 0U;
       element_type bit = element_type(0);
 
-      if (number_of_elements == 0)
+      if (number_of_elements == 0) ETL_UNLIKELY
       {
         return;
       }
@@ -454,7 +589,7 @@ namespace etl
       size_t       index = 0U;
       element_type bit = element_type(0);
       
-      if (number_of_elements == 0)
+      if (number_of_elements == 0) ETL_UNLIKELY
       {
         return;
       }
@@ -1265,7 +1400,7 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
       value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
@@ -1283,6 +1418,40 @@ namespace etl
       return v;
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+    {
+      ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
+
+      element_type mask = (~(~0u << length) << position);
+      T value((buffer & mask) >> position);
+
+      return value;
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract() const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
+      
+      element_type mask = (~(~0u << Length) << Position);
+      T value((buffer & mask) >> Position);
+
+      return value;
+    }
+
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
@@ -2041,6 +2210,42 @@ namespace etl
       return ibitset.template value<T>(buffer, Number_Of_Elements);
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+    {
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
+
+      return ibitset.extract_from_multi_element<T>(buffer, position, length);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+    ETL_CONSTEXPR14
+      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract() const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
+
+      const int active_bits_in_element = ((Position + Length) % Bits_Per_Element);
+
+      // Is the value contained within one element?
+      if (active_bits_in_element == Length)
+      {
+        return ibitset.extract_from_single_element<T, Position, Length>(buffer);
+      }
+      else
+      {
+        return ibitset.extract_from_multi_element<T, Position, Length>(buffer);
+      }
+    }
+
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
@@ -3002,6 +3207,38 @@ namespace etl
       return v;
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+    {
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
+
+      element_type mask = (~(~0u << length) << position);
+      T v((*pbuffer & mask) >> position);
+
+      return v;
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+    ETL_CONSTEXPR14
+      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract() const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
+
+      element_type mask = (~(~0u << Length) << Position);
+      T v((*pbuffer & mask) >> Position);
+
+      return v;
+    }
+
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
@@ -3762,7 +3999,7 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
       value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
@@ -3771,6 +4008,42 @@ namespace etl
       return ibitset.template value<T>(pbuffer, Number_Of_Elements);
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+    {
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
+
+      return ibitset.extract_from_multi_element<T>(pbuffer, position, length);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      extract() const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
+
+      const int active_bits_in_element = ((Position + Length) % Bits_Per_Element);
+
+      // Is the value contained within one element?
+      if (active_bits_in_element == Length)
+      {
+        return ibitset.extract_from_single_element<T, Position, Length>(pbuffer);
+      }
+      else
+      {
+        return ibitset.extract_from_multi_element<T, Position, Length>(pbuffer);
+      }
+    }
+
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index 95da4aad..af437e94 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -2237,5 +2237,75 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    //*************************************************************************
+    TEST(test_extract_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+      
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //uint8_t v = b.extract<uint8_t, 25, 8>();
+      //uint8_t v = b.extract<uint8_t, 25, 9>();
+    }
   };
 }
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index 78de4ef3..3b4c91dd 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -1725,5 +1725,74 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    //*************************************************************************
+    TEST(test_extract_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL(0x78, b.extract<uint8_t>(0, 8));
+      CHECK_EQUAL(0x3C, b.extract<uint8_t>(1, 8));
+      CHECK_EQUAL(0x9E, b.extract<uint8_t>(2, 8));
+      CHECK_EQUAL(0xCF, b.extract<uint8_t>(3, 8));
+      CHECK_EQUAL(0x67, b.extract<uint8_t>(4, 8));
+      CHECK_EQUAL(0xB3, b.extract<uint8_t>(5, 8));
+      CHECK_EQUAL(0x59, b.extract<uint8_t>(6, 8));
+      CHECK_EQUAL(0xAC, b.extract<uint8_t>(7, 8));
+      CHECK_EQUAL(0x56, b.extract<uint8_t>(8, 8));
+      CHECK_EQUAL(0x2B, b.extract<uint8_t>(9, 8));
+      CHECK_EQUAL(0x15, b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL(0x8A, b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL(0x45, b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL(0xA2, b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL(0xD1, b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL(0x68, b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL(0x34, b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL(0x1A, b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL(0x8D, b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL(0x46, b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL(0x23, b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL(0x91, b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL(0x48, b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL(0x24, b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL(0x12, b.extract<uint8_t>(24, 8));
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL(0x78, (b.extract<uint8_t, 0, 8>()));
+      CHECK_EQUAL(0x3C, (b.extract<uint8_t, 1, 8>()));
+      CHECK_EQUAL(0x9E, (b.extract<uint8_t, 2, 8>()));
+      CHECK_EQUAL(0xCF, (b.extract<uint8_t, 3, 8>()));
+      CHECK_EQUAL(0x67, (b.extract<uint8_t, 4, 8>()));
+      CHECK_EQUAL(0xB3, (b.extract<uint8_t, 5, 8>()));
+      CHECK_EQUAL(0x59, (b.extract<uint8_t, 6, 8>()));
+      CHECK_EQUAL(0xAC, (b.extract<uint8_t, 7, 8>()));
+      CHECK_EQUAL(0x56, (b.extract<uint8_t, 8, 8>()));
+      CHECK_EQUAL(0x2B, (b.extract<uint8_t, 9, 8>()));
+      CHECK_EQUAL(0x15, (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL(0x8A, (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL(0x45, (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL(0xA2, (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL(0xD1, (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL(0x68, (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL(0x34, (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL(0x1A, (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL(0x8D, (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL(0x46, (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL(0x23, (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL(0x91, (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL(0x48, (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL(0x24, (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL(0x12, (b.extract<uint8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //uint8_t v = b.extract<uint8_t, 25, 8>();
+      //uint8_t v = b.extract<uint8_t, 25, 9>();
+    }
   };
 }
diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp
index 8eb3cbb6..8bd56537 100644
--- a/test/test_bitset_new_ext_default_element_type.cpp
+++ b/test/test_bitset_new_ext_default_element_type.cpp
@@ -2130,5 +2130,79 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    //*************************************************************************
+    TEST(test_extract_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+    }
+
+    //*************************************************************************
+    TEST(test_extract_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The line below should static assert.
+      //uint8_t v = b.extract<uint8_t, 25, 8>();
+      //uint8_t v = b.extract<uint8_t, 25, 9>();
+    }
   };
 }
diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp
index 0eaf1d19..07889e64 100644
--- a/test/test_bitset_new_ext_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp
@@ -1478,5 +1478,79 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    //*************************************************************************
+    TEST(test_extract_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, int32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+    }
+
+    //*************************************************************************
+    TEST(test_extract_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, int32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The line below should static assert.
+      //uint8_t v = b.extract<uint8_t, 25, 8>();
+      //uint8_t v = b.extract<uint8_t, 25, 9>();
+    }
   };
 }
diff --git a/test/vs2022/etl.vcxproj b/test/vs2022/etl.vcxproj
index 4c18142c..473d635c 100644
--- a/test/vs2022/etl.vcxproj
+++ b/test/vs2022/etl.vcxproj
@@ -839,17 +839,17 @@
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - Force C++03|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No virtual messages|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
@@ -859,37 +859,37 @@
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++ 20 - No Tests|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
@@ -935,7 +935,7 @@
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14 - No STL|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>

From 2c8aafedcdbfa0c85e3fbd98a86f506df6fdcb1d Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Fri, 1 Dec 2023 17:21:48 +0000
Subject: [PATCH 11/26] Work in progress for etl::bitset::extract

---
 include/etl/private/bitset_new.h              | 186 +++++-----
 test/test_bitset_new_default_element_type.cpp | 326 +++++++++++++++++-
 ...itset_new_explicit_single_element_type.cpp |   4 +-
 ...st_bitset_new_ext_default_element_type.cpp |   4 +-
 ...t_new_ext_explicit_single_element_type.cpp |   4 +-
 5 files changed, 412 insertions(+), 112 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 530f5c6a..ce1688cd 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -159,6 +159,12 @@ namespace etl
     static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
     static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
 
+    template <size_t Position, size_t Length, size_t Bits_Per_Element>
+    struct value_is_in_one_element
+    {
+      static ETL_CONSTANT bool value = ((Position + Length - 1) >> etl::log2<Bits_Per_Element>::value) == (Position >> etl::log2<Bits_Per_Element>::value);
+    };
+
     //*************************************************************************
     /// Count the number of bits set.
     //*************************************************************************
@@ -414,63 +420,56 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    T extract_from_single_element(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
+    T extract_from_buffer(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
       unsigned_t value(0);
 
-      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
-      const int        element_index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
-      const unsigned_t Shift = position % Bits_Per_Element;
+      const int Msb_Element_Index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const int Lsb_Element_Index = position >> etl::log2<Bits_Per_Element>::value;
 
-      value = static_cast<unsigned_t>(pbuffer[element_index] >> Shift) & value_mask;
-
-      return static_cast<T>(value);
-    }
-
-    //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    T extract_from_multi_element(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
-    {
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      unsigned_t value(0);
-
-      // The mask for the value type.
-      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
-
-      // Find the index of the element containing the msb.
-      int element_index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
-
-      // The value is spread over multiple elements.       
-      element_type bit_mask = element_type(1) << ((position + length - 1) % Bits_Per_Element);
-
-      while (length != 0)
+      // Is the value contained within one element?
+      if (Msb_Element_Index == Lsb_Element_Index)
       {
-        // TODO Optimise this to read whole element values.
+        const unsigned_t Mask = ~(~0 << length);
+        const unsigned_t Shift = position % Bits_Per_Element;
 
-        value <<= 1;
+        value = static_cast<unsigned_t>(pbuffer[Msb_Element_Index] >> Shift) & Mask;
+      }
+      else
+      {
+        // Get the number of active bits in the msb element 
+        size_t active_bits_in_msb = (position + length) - (Msb_Element_Index * Bits_Per_Element);
 
-        const bool is_set = (pbuffer[element_index] & bit_mask) != 0;
+        // Extract the first element if partially filled.
+        // Start with index of the element containing the msb.
+        int element_index = Msb_Element_Index;
 
-        if (is_set)
+        if (active_bits_in_msb < Bits_Per_Element)
         {
-          value |= unsigned_t(1);
-        }
-
-        bit_mask >>= 1;
-
-        if (bit_mask == 0)
-        {
-          bit_mask = element_type(1) << (Bits_Per_Element - 1);
+          element_type mask = ~(~element_type(0) << active_bits_in_msb);
+          value |= pbuffer[element_index] & mask;
+          length -= active_bits_in_msb;
           --element_index;
         }
 
-        --length;
+        // Loop through the fully filled elements
+        while (length >= Bits_Per_Element)
+        {
+          value <<= Bits_Per_Element;
+          value |= pbuffer[element_index];
+          length -= Bits_Per_Element;
+          --element_index;
+        }
+
+        // Check if the last element is partially filled and extract.
+        if (length != 0)
+        {
+          value <<= length;
+          element_type mask = ~(~element_type(0) << length);
+          value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
+        }
       }
 
       return static_cast<T>(value);
@@ -481,17 +480,16 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
-    T extract_from_single_element(const_pointer pbuffer) const
+    typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, T>::type
+      extract_from_buffer(const_pointer pbuffer) const
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      unsigned_t value(0);
-
-      const unsigned_t value_mask    = etl::integral_limits<unsigned_t>::max;
-      const int        element_index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const int        Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const unsigned_t Mask          = ~(~0 << Length);
       const unsigned_t Shift         = Position % Bits_Per_Element;
-
-      value = static_cast<unsigned_t>(pbuffer[element_index] >> Shift) & value_mask;
+      
+      unsigned_t value = static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
 
       return static_cast<T>(value);
     }
@@ -501,44 +499,48 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
-    T extract_from_multi_element(const_pointer pbuffer) const
+    typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, T>::type
+      extract_from_buffer(const_pointer pbuffer) const
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
       unsigned_t value(0);
 
-      // The mask for the value type.
-      const unsigned_t value_mask = etl::integral_limits<unsigned_t>::max;
+      const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
 
-      // Find the index of the element containing the msb.
-      int element_index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+      // Start with index of the element containing the msb.
+      int element_index = Msb_Element_Index;
 
       // The value is spread over multiple elements.       
-      size_t       length   = Length;
-      element_type bit_mask = element_type(1) << ((Position + Length - 1) % Bits_Per_Element);
+      size_t length = Length;
 
-      while (length != 0)
+      // Get the number of active bits in the first element 
+      size_t active_bits_in_element = ((Position + Length - 1) % Bits_Per_Element) + 1;
+
+      // Extract the first element if partially filled.
+      if (active_bits_in_element < Bits_Per_Element)
       {
-        // TODO Optimise this to read whole element values.
+        element_type mask = ~(~element_type(0) << active_bits_in_element);
+        value |= pbuffer[element_index] & mask;
+        length -= active_bits_in_element;
+        --element_index;
+      }
 
-        value <<= 1;
+      // Loop through the fully filled elements
+      while (length >= Bits_Per_Element)
+      {
+        value <<= Bits_Per_Element;
+        value |= pbuffer[element_index];
+        length -= Bits_Per_Element;
+        --element_index;
+      }
 
-        const bool is_set = (pbuffer[element_index] & bit_mask) != 0;
-
-        if (is_set)
-        {
-          value |= unsigned_t(1);
-        }      
-
-        bit_mask >>= 1;
-
-        if (bit_mask == 0)
-        {
-          bit_mask = element_type(1) << (Bits_Per_Element - 1);
-          --element_index;
-        }
-
-        --length;
+      // Check if the last element is partially filled and extract.
+      if (length != 0)
+      {
+        value <<= length;
+        element_type mask = ~(~element_type(0) << length);
+        value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
       }
 
       return static_cast<T>(value);
@@ -2201,7 +2203,7 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
       value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
@@ -2220,7 +2222,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.extract_from_multi_element<T>(buffer, position, length);
+      return ibitset.extract_from_buffer<T>(buffer, position, length);
     }
 
     //*************************************************************************
@@ -2228,22 +2230,12 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
       extract() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      const int active_bits_in_element = ((Position + Length) % Bits_Per_Element);
-
-      // Is the value contained within one element?
-      if (active_bits_in_element == Length)
-      {
-        return ibitset.extract_from_single_element<T, Position, Length>(buffer);
-      }
-      else
-      {
-        return ibitset.extract_from_multi_element<T, Position, Length>(buffer);
-      }
+      return ibitset.extract_from_buffer<T, Position, Length>(buffer);
     }
 
     //*************************************************************************
@@ -4018,7 +4010,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.extract_from_multi_element<T>(pbuffer, position, length);
+      return ibitset.extract_from_buffer<T>(pbuffer, position, length);
     }
 
     //*************************************************************************
@@ -4031,17 +4023,7 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      const int active_bits_in_element = ((Position + Length) % Bits_Per_Element);
-
-      // Is the value contained within one element?
-      if (active_bits_in_element == Length)
-      {
-        return ibitset.extract_from_single_element<T, Position, Length>(pbuffer);
-      }
-      else
-      {
-        return ibitset.extract_from_multi_element<T, Position, Length>(pbuffer);
-      }
+      return ibitset.extract_from_buffer<T, Position, Length>(pbuffer);
     }
 
     //*************************************************************************
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index af437e94..b49f5c9a 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -2239,7 +2239,82 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_run_time_parameters)
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint8_t_with_run_time_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
@@ -2269,11 +2344,12 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
       CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
       
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
       CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
 
     //*************************************************************************
-    TEST(test_extract_with_template_parameters)
+    TEST(test_extract_uint8_t_with_template_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
@@ -2304,8 +2380,250 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
 
       // The lines below should static assert.
-      //uint8_t v = b.extract<uint8_t, 25, 8>();
-      //uint8_t v = b.extract<uint8_t, 25, 9>();
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
+      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
+      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
+      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
+      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
+      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
+      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
+      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
+      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
+      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
+      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
+      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
+      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+
+      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 24, 9>();
+      //int8_t v2 = b.extract<int8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19,13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>(0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>(1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>(2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>(3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>(4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>(5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>(6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>(7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>(8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>(9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
+      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+
+      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t, 0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t, 1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t, 2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t, 3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t, 4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t, 5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t, 6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t, 7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t, 8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t, 9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //int16_t v1 = b.extract<int16_t, 16, 17>());
+      //int16_t v2 = b.extract<int16_t, 17, 16>());
     }
   };
 }
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index 3b4c91dd..4ea4992e 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -1727,7 +1727,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_run_time_parameters)
+    TEST(test_extract_uint8_t_with_run_time_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
 
@@ -1760,7 +1760,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_template_parameters)
+    TEST(test_extract_uint8_t_with_template_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
 
diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp
index 8bd56537..07025ff3 100644
--- a/test/test_bitset_new_ext_default_element_type.cpp
+++ b/test/test_bitset_new_ext_default_element_type.cpp
@@ -2132,7 +2132,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_run_time_parameters)
+    TEST(test_extract_uint8_t_with_run_time_parameters)
     {
       using bs32 = etl::bitset_ext<32>;
 
@@ -2167,7 +2167,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_template_parameters)
+    TEST(test_extract_uint8_t_with_template_parameters)
     {
       using bs32 = etl::bitset_ext<32>;
 
diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp
index 07889e64..af31e5b7 100644
--- a/test/test_bitset_new_ext_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp
@@ -1480,7 +1480,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_run_time_parameters)
+    TEST(test_extract_uint8_t_with_run_time_parameters)
     {
       using bs32 = etl::bitset_ext<32, int32_t>;
 
@@ -1515,7 +1515,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_extract_with_template_parameters)
+    TEST(test_extract_uint8_t_with_template_parameters)
     {
       using bs32 = etl::bitset_ext<32, int32_t>;
 

From 236af6190a3060ed7aeb4c498a9a1124a2018ea8 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Sat, 2 Dec 2023 17:46:38 +0000
Subject: [PATCH 12/26] Work in progress for etl::bitset::extract

---
 include/etl/private/bitset_new.h              | 148 ++++++++++--------
 test/test_bitset_new_default_element_type.cpp |  77 +++++++++
 2 files changed, 158 insertions(+), 67 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index ce1688cd..c3480ec7 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -415,12 +415,62 @@ namespace etl
       return v;
     }
 
+    //*************************************************************************
+    /// Extract an value from multiple elements.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::make_unsigned<T>::type extract_from_multiple_elements(const element_type* pbuffer,
+                                                                        int                 element_index,
+                                                                        size_t              active_bits_in_msb,
+                                                                        size_t              length) const ETL_NOEXCEPT
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      // Extract the first element, if partially filled.
+      if (active_bits_in_msb < Bits_Per_Element)
+      {
+        element_type mask = ~(~element_type(0) << active_bits_in_msb);
+        value = pbuffer[element_index] & mask;
+        length -= active_bits_in_msb;
+        if (length >= Bits_Per_Element)
+        {
+          value = value << Bits_Per_Element;
+        }
+        --element_index;
+      }
+
+      // Loop through the fully filled elements
+      while (length >= Bits_Per_Element)
+      {
+        value |= pbuffer[element_index];
+        length -= Bits_Per_Element;
+        if (length >= Bits_Per_Element)
+        {
+          value = value << Bits_Per_Element;
+        }
+        --element_index;
+      }
+
+      // Extract the last element, if partially filled.
+      if (length != 0)
+      {
+        value = value << length;
+        element_type mask = ~(~element_type(0) << length);
+        value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
+      }
+
+      return value;
+    }
+
     //*************************************************************************
     /// Extract an integral value from an arbitary position and length.
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    T extract_from_buffer(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
+    typename etl::make_unsigned<T>::type extract_from_buffer(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
@@ -442,37 +492,13 @@ namespace etl
         // Get the number of active bits in the msb element 
         size_t active_bits_in_msb = (position + length) - (Msb_Element_Index * Bits_Per_Element);
 
-        // Extract the first element if partially filled.
         // Start with index of the element containing the msb.
         int element_index = Msb_Element_Index;
 
-        if (active_bits_in_msb < Bits_Per_Element)
-        {
-          element_type mask = ~(~element_type(0) << active_bits_in_msb);
-          value |= pbuffer[element_index] & mask;
-          length -= active_bits_in_msb;
-          --element_index;
-        }
-
-        // Loop through the fully filled elements
-        while (length >= Bits_Per_Element)
-        {
-          value <<= Bits_Per_Element;
-          value |= pbuffer[element_index];
-          length -= Bits_Per_Element;
-          --element_index;
-        }
-
-        // Check if the last element is partially filled and extract.
-        if (length != 0)
-        {
-          value <<= length;
-          element_type mask = ~(~element_type(0) << length);
-          value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
-        }
+        value = extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
       }
 
-      return static_cast<T>(value);
+      return value;
     }
 
     //*************************************************************************
@@ -480,7 +506,7 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
-    typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, T>::type
+    typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
       extract_from_buffer(const_pointer pbuffer) const
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
@@ -489,9 +515,7 @@ namespace etl
       const unsigned_t Mask          = ~(~0 << Length);
       const unsigned_t Shift         = Position % Bits_Per_Element;
       
-      unsigned_t value = static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
-
-      return static_cast<T>(value);
+      return  static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
     }
 
     //*************************************************************************
@@ -499,13 +523,11 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
-    typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, T>::type
+    typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
       extract_from_buffer(const_pointer pbuffer) const
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      unsigned_t value(0);
-
+       
       const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
 
       // Start with index of the element containing the msb.
@@ -515,35 +537,9 @@ namespace etl
       size_t length = Length;
 
       // Get the number of active bits in the first element 
-      size_t active_bits_in_element = ((Position + Length - 1) % Bits_Per_Element) + 1;
+      size_t active_bits_in_msb = ((Position + Length - 1) % Bits_Per_Element) + 1;
 
-      // Extract the first element if partially filled.
-      if (active_bits_in_element < Bits_Per_Element)
-      {
-        element_type mask = ~(~element_type(0) << active_bits_in_element);
-        value |= pbuffer[element_index] & mask;
-        length -= active_bits_in_element;
-        --element_index;
-      }
-
-      // Loop through the fully filled elements
-      while (length >= Bits_Per_Element)
-      {
-        value <<= Bits_Per_Element;
-        value |= pbuffer[element_index];
-        length -= Bits_Per_Element;
-        --element_index;
-      }
-
-      // Check if the last element is partially filled and extract.
-      if (length != 0)
-      {
-        value <<= length;
-        element_type mask = ~(~element_type(0) << length);
-        value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
-      }
-
-      return static_cast<T>(value);
+      return extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
     }
 
     //*************************************************************************
@@ -2222,7 +2218,16 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.extract_from_buffer<T>(buffer, position, length);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = ibitset.template extract_from_buffer<T>(buffer, position, length);;
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return value;
     }
 
     //*************************************************************************
@@ -2235,7 +2240,16 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      return ibitset.extract_from_buffer<T, Position, Length>(buffer);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = ibitset.template extract_from_buffer<T, Position, Length>(buffer);
+
+      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T, Length>(value);
+      }
+
+      return value;
     }
 
     //*************************************************************************
@@ -4010,7 +4024,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.extract_from_buffer<T>(pbuffer, position, length);
+      return ibitset.template extract_from_buffer<T>(pbuffer, position, length);
     }
 
     //*************************************************************************
@@ -4023,7 +4037,7 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      return ibitset.extract_from_buffer<T, Position, Length>(pbuffer);
+      return ibitset.template extract_from_buffer<T, Position, Length>(pbuffer);
     }
 
     //*************************************************************************
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index b49f5c9a..19aede7b 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -2313,6 +2313,83 @@ namespace
       //uint8_t v1 = b.extract<uint8_t, 27, 6>();
     }
 
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      auto v = b.extract<int8_t>(1, 6);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
     //*************************************************************************
     TEST(test_extract_uint8_t_with_run_time_parameters)
     {

From aa4b27b6e6dbc82a39873da14441dece610904d2 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Mon, 4 Dec 2023 08:37:59 +0000
Subject: [PATCH 13/26] Work in progress for etl::bitset::extract

---
 include/etl/private/bitset_new.h              | 100 +++-
 test/test_bitset_new_default_element_type.cpp |  82 ++-
 ...itset_new_explicit_single_element_type.cpp | 498 ++++++++++++++++--
 ...st_bitset_new_ext_default_element_type.cpp | 437 ++++++++++++++-
 ...t_new_ext_explicit_single_element_type.cpp | 441 +++++++++++++++-
 5 files changed, 1432 insertions(+), 126 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index c3480ec7..2257b838 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -432,7 +432,7 @@ namespace etl
       // Extract the first element, if partially filled.
       if (active_bits_in_msb < Bits_Per_Element)
       {
-        element_type mask = ~(~element_type(0) << active_bits_in_msb);
+        element_type mask = etl::make_lsb_mask< element_type>(active_bits_in_msb);
         value = pbuffer[element_index] & mask;
         length -= active_bits_in_msb;
         if (length >= Bits_Per_Element)
@@ -458,7 +458,7 @@ namespace etl
       if (length != 0)
       {
         value = value << length;
-        element_type mask = ~(~element_type(0) << length);
+        element_type mask = etl::make_lsb_mask< element_type>(length);
         value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
       }
 
@@ -482,7 +482,7 @@ namespace etl
       // Is the value contained within one element?
       if (Msb_Element_Index == Lsb_Element_Index)
       {
-        const unsigned_t Mask = ~(~0 << length);
+        const unsigned_t Mask  = etl::make_lsb_mask< unsigned_t>(length);
         const unsigned_t Shift = position % Bits_Per_Element;
 
         value = static_cast<unsigned_t>(pbuffer[Msb_Element_Index] >> Shift) & Mask;
@@ -512,7 +512,7 @@ namespace etl
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
       const int        Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
-      const unsigned_t Mask          = ~(~0 << Length);
+      const unsigned_t Mask          = etl::lsb_mask<unsigned_t, Length>::value;
       const unsigned_t Shift         = Position % Bits_Per_Element;
       
       return  static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
@@ -525,9 +525,7 @@ namespace etl
     ETL_CONSTEXPR14
     typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
       extract_from_buffer(const_pointer pbuffer) const
-    {
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
-       
+    {      
       const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
 
       // Start with index of the element containing the msb.
@@ -992,7 +990,7 @@ namespace etl
   /// Specialisation that uses a single element if the element type is the 
   /// same size as the number of active bits.
   //***************************************************************************
-  template <size_t   Active_Bits, typename TElement>
+  template <size_t Active_Bits, typename TElement>
   class bitset<Active_Bits, TElement, true> : public bitset_constants<>
   {
   public:
@@ -1427,10 +1425,19 @@ namespace etl
       ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
 
-      element_type mask = (~(~0u << length) << position);
-      T value((buffer & mask) >> position);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      return value;
+      const unsigned_t Mask  = etl::make_lsb_mask< unsigned_t>(length);
+      const unsigned_t Shift = position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(buffer >> Shift) & Mask;
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -1444,10 +1451,19 @@ namespace etl
       ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
       
-      element_type mask = (~(~0u << Length) << Position);
-      T value((buffer & mask) >> Position);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      return value;
+      const unsigned_t Mask  = etl::make_lsb_mask<unsigned_t, Length>();
+      const unsigned_t Shift = Position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(buffer >> Shift) & Mask;
+
+      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T, Length>(value);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -2227,7 +2243,7 @@ namespace etl
         value = etl::sign_extend<T>(value, length);
       }
 
-      return value;
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -2249,7 +2265,7 @@ namespace etl
         value = etl::sign_extend<T, Length>(value);
       }
 
-      return value;
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -3223,10 +3239,19 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      element_type mask = (~(~0u << length) << position);
-      T v((*pbuffer & mask) >> position);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      return v;
+      const unsigned_t Mask = etl::make_lsb_mask<unsigned_t>(length);
+      const unsigned_t Shift = position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -3239,10 +3264,19 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      element_type mask = (~(~0u << Length) << Position);
-      T v((*pbuffer & mask) >> Position);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      return v;
+      const unsigned_t Mask = etl::make_lsb_mask<unsigned_t, Length>();
+      const unsigned_t Shift = Position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
+
+      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T, Length>(value);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -4024,7 +4058,16 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
 
-      return ibitset.template extract_from_buffer<T>(pbuffer, position, length);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = ibitset.template extract_from_buffer<T>(pbuffer, position, length);
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -4037,7 +4080,16 @@ namespace etl
     {
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
 
-      return ibitset.template extract_from_buffer<T, Position, Length>(pbuffer);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = ibitset.template extract_from_buffer<T, Position, Length>(pbuffer);
+
+      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T, Length>(value);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index 19aede7b..b22f5a44 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -2318,18 +2318,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      auto v = b.extract<int8_t>(1, 6);
-
-      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
       CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
       CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
@@ -2357,16 +2355,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
@@ -2653,16 +2651,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>(0, 16));
-      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>(1, 16));
-      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>(2, 16));
-      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>(3, 16));
-      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>(4, 16));
-      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>(5, 16));
-      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>(6, 16));
-      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>(7, 16));
-      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>(8, 16));
-      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>(9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
       CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
       CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
       CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
@@ -2680,16 +2678,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t, 0, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t, 1, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t, 2, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t, 3, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t, 4, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t, 5, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t, 6, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t, 7, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t, 8, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t, 9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
       CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
       CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
       CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index 4ea4992e..05ed79a9 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -1726,36 +1726,188 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
 
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
     //*************************************************************************
     TEST(test_extract_uint8_t_with_run_time_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
 
-      CHECK_EQUAL(0x78, b.extract<uint8_t>(0, 8));
-      CHECK_EQUAL(0x3C, b.extract<uint8_t>(1, 8));
-      CHECK_EQUAL(0x9E, b.extract<uint8_t>(2, 8));
-      CHECK_EQUAL(0xCF, b.extract<uint8_t>(3, 8));
-      CHECK_EQUAL(0x67, b.extract<uint8_t>(4, 8));
-      CHECK_EQUAL(0xB3, b.extract<uint8_t>(5, 8));
-      CHECK_EQUAL(0x59, b.extract<uint8_t>(6, 8));
-      CHECK_EQUAL(0xAC, b.extract<uint8_t>(7, 8));
-      CHECK_EQUAL(0x56, b.extract<uint8_t>(8, 8));
-      CHECK_EQUAL(0x2B, b.extract<uint8_t>(9, 8));
-      CHECK_EQUAL(0x15, b.extract<uint8_t>(10, 8));
-      CHECK_EQUAL(0x8A, b.extract<uint8_t>(11, 8));
-      CHECK_EQUAL(0x45, b.extract<uint8_t>(12, 8));
-      CHECK_EQUAL(0xA2, b.extract<uint8_t>(13, 8));
-      CHECK_EQUAL(0xD1, b.extract<uint8_t>(14, 8));
-      CHECK_EQUAL(0x68, b.extract<uint8_t>(15, 8));
-      CHECK_EQUAL(0x34, b.extract<uint8_t>(16, 8));
-      CHECK_EQUAL(0x1A, b.extract<uint8_t>(17, 8));
-      CHECK_EQUAL(0x8D, b.extract<uint8_t>(18, 8));
-      CHECK_EQUAL(0x46, b.extract<uint8_t>(19, 8));
-      CHECK_EQUAL(0x23, b.extract<uint8_t>(20, 8));
-      CHECK_EQUAL(0x91, b.extract<uint8_t>(21, 8));
-      CHECK_EQUAL(0x48, b.extract<uint8_t>(22, 8));
-      CHECK_EQUAL(0x24, b.extract<uint8_t>(23, 8));
-      CHECK_EQUAL(0x12, b.extract<uint8_t>(24, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
       CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
 
@@ -1764,35 +1916,277 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
 
-      CHECK_EQUAL(0x78, (b.extract<uint8_t, 0, 8>()));
-      CHECK_EQUAL(0x3C, (b.extract<uint8_t, 1, 8>()));
-      CHECK_EQUAL(0x9E, (b.extract<uint8_t, 2, 8>()));
-      CHECK_EQUAL(0xCF, (b.extract<uint8_t, 3, 8>()));
-      CHECK_EQUAL(0x67, (b.extract<uint8_t, 4, 8>()));
-      CHECK_EQUAL(0xB3, (b.extract<uint8_t, 5, 8>()));
-      CHECK_EQUAL(0x59, (b.extract<uint8_t, 6, 8>()));
-      CHECK_EQUAL(0xAC, (b.extract<uint8_t, 7, 8>()));
-      CHECK_EQUAL(0x56, (b.extract<uint8_t, 8, 8>()));
-      CHECK_EQUAL(0x2B, (b.extract<uint8_t, 9, 8>()));
-      CHECK_EQUAL(0x15, (b.extract<uint8_t, 10, 8>()));
-      CHECK_EQUAL(0x8A, (b.extract<uint8_t, 11, 8>()));
-      CHECK_EQUAL(0x45, (b.extract<uint8_t, 12, 8>()));
-      CHECK_EQUAL(0xA2, (b.extract<uint8_t, 13, 8>()));
-      CHECK_EQUAL(0xD1, (b.extract<uint8_t, 14, 8>()));
-      CHECK_EQUAL(0x68, (b.extract<uint8_t, 15, 8>()));
-      CHECK_EQUAL(0x34, (b.extract<uint8_t, 16, 8>()));
-      CHECK_EQUAL(0x1A, (b.extract<uint8_t, 17, 8>()));
-      CHECK_EQUAL(0x8D, (b.extract<uint8_t, 18, 8>()));
-      CHECK_EQUAL(0x46, (b.extract<uint8_t, 19, 8>()));
-      CHECK_EQUAL(0x23, (b.extract<uint8_t, 20, 8>()));
-      CHECK_EQUAL(0x91, (b.extract<uint8_t, 21, 8>()));
-      CHECK_EQUAL(0x48, (b.extract<uint8_t, 22, 8>()));
-      CHECK_EQUAL(0x24, (b.extract<uint8_t, 23, 8>()));
-      CHECK_EQUAL(0x12, (b.extract<uint8_t, 24, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
 
       // The lines below should static assert.
-      //uint8_t v = b.extract<uint8_t, 25, 8>();
-      //uint8_t v = b.extract<uint8_t, 25, 9>();
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
+      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
+      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
+      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
+      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
+      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
+      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
+      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
+      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
+      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
+      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
+      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
+      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+
+      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 24, 9>();
+      //int8_t v2 = b.extract<int8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
+      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+
+      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //int16_t v1 = b.extract<int16_t, 16, 17>());
+      //int16_t v2 = b.extract<int16_t, 17, 16>());
     }
   };
 }
diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp
index 07025ff3..7cd47788 100644
--- a/test/test_bitset_new_ext_default_element_type.cpp
+++ b/test/test_bitset_new_ext_default_element_type.cpp
@@ -2131,6 +2131,168 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
 
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
     //*************************************************************************
     TEST(test_extract_uint8_t_with_run_time_parameters)
     {
@@ -2164,6 +2326,9 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
       CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
       CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
 
     //*************************************************************************
@@ -2200,9 +2365,275 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
       CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
 
-      // The line below should static assert.
-      //uint8_t v = b.extract<uint8_t, 25, 8>();
-      //uint8_t v = b.extract<uint8_t, 25, 9>();
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
+      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
+      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
+      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
+      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
+      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
+      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
+      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
+      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
+      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
+      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
+      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
+      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+
+      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 24, 9>();
+      //int8_t v2 = b.extract<int8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
+      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+
+      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //int16_t v1 = b.extract<int16_t, 16, 17>());
+      //int16_t v2 = b.extract<int16_t, 17, 16>());
     }
   };
 }
diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp
index af31e5b7..4b3d3948 100644
--- a/test/test_bitset_new_ext_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp
@@ -1479,10 +1479,172 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
 
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
     //*************************************************************************
     TEST(test_extract_uint8_t_with_run_time_parameters)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
@@ -1512,12 +1674,15 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
       CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
       CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
 
     //*************************************************************************
     TEST(test_extract_uint8_t_with_template_parameters)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
@@ -1548,9 +1713,275 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
       CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
 
-      // The line below should static assert.
-      //uint8_t v = b.extract<uint8_t, 25, 8>();
-      //uint8_t v = b.extract<uint8_t, 25, 9>();
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
+      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
+      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
+      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
+      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
+      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
+      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
+      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
+      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
+      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
+      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
+      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
+      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+
+      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 24, 9>();
+      //int8_t v2 = b.extract<int8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
+      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+
+      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //int16_t v1 = b.extract<int16_t, 16, 17>());
+      //int16_t v2 = b.extract<int16_t, 17, 16>());
     }
   };
 }

From c5c88ae010e059cf9596645f7b970008c0f9c492 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Wed, 13 Dec 2023 09:59:59 +0000
Subject: [PATCH 14/26] Work in progress

---
 include/etl/private/bitset_new.h | 48 ++++++++++++++++++++++----------
 1 file changed, 33 insertions(+), 15 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 2257b838..71fd8ea1 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -966,7 +966,7 @@ namespace etl
   //***************************************************************************
   template <size_t Active_Bits = 0U,
             typename TElement = char,
-            bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
+            bool FitsInSingleElement = etl::integral_limits<TElement>::bits >= Active_Bits>
   class bitset;
 
   //***************************************************************************
@@ -976,6 +976,20 @@ namespace etl
   template <>
   class bitset<0U, char, true> : public bitset_constants<>
   {
+  public:
+
+    typedef char element_type;
+
+    typedef element_type*       pointer;
+    typedef const element_type* const_pointer;
+
+    static ETL_CONSTANT size_t       Bits_Per_Element   = 0U;
+    static ETL_CONSTANT size_t       Number_Of_Elements = 0U;
+    static ETL_CONSTANT size_t       Allocated_Bits     = 0U;
+    static ETL_CONSTANT element_type All_Set_Element    = 0U;
+    static ETL_CONSTANT element_type All_Clear_Element  = 0U;
+    static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
+    static ETL_CONSTANT element_type Top_Mask           = 0U;
   };
 
   //***************************************************************************
@@ -984,11 +998,25 @@ namespace etl
   template <>
   class bitset<0U, char, false> : public bitset_constants<>
   {
+  public:
+
+    typedef char element_type;
+
+    typedef element_type*       pointer;
+    typedef const element_type* const_pointer;
+
+    static ETL_CONSTANT size_t       Bits_Per_Element   = 0U;
+    static ETL_CONSTANT size_t       Number_Of_Elements = 0U;
+    static ETL_CONSTANT size_t       Allocated_Bits     = 0U;
+    static ETL_CONSTANT element_type All_Set_Element    = 0U;
+    static ETL_CONSTANT element_type All_Clear_Element  = 0U;
+    static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
+    static ETL_CONSTANT element_type Top_Mask           = 0U;
   };
 
   //***************************************************************************
-  /// Specialisation that uses a single element if the element type is the 
-  /// same size as the number of active bits.
+  /// Specialisation that uses a single element if the number of active bits
+  /// fits into the element type size.
   //***************************************************************************
   template <size_t Active_Bits, typename TElement>
   class bitset<Active_Bits, TElement, true> : public bitset_constants<>
@@ -1177,16 +1205,6 @@ namespace etl
       return *this;
     }
 
-    //*************************************************************************
-    /// Set from a value.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(element_type value) ETL_NOEXCEPT
-    {
-      buffer = value;
-
-      return *this;
-    }
-
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
@@ -3333,7 +3351,7 @@ namespace etl
     //*************************************************************************
     /// The number of bits in the bitset.
     //*************************************************************************
-    ETL_CONSTEXPR14  size_t size() const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
     {
       return Active_Bits;
     }
@@ -4143,7 +4161,7 @@ namespace etl
     //*************************************************************************
     /// The number of bits in the bitset.
     //*************************************************************************
-    ETL_CONSTEXPR14  size_t size() const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
     {
       return Active_Bits;
     }

From 58f469ebd43a1ac851917fcf8d10d95b4459ea68 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Fri, 29 Dec 2023 09:33:20 +0000
Subject: [PATCH 15/26] Work in progress

Finished updating explicit single element tests
---
 include/etl/private/bitset_new.h              | 3864 ++++++-----------
 ...itset_new_explicit_single_element_type.cpp |  926 ++--
 2 files changed, 1897 insertions(+), 2893 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 71fd8ea1..7a766f64 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -76,14 +76,81 @@ SOFTWARE.
 
 namespace etl
 {
-  template <typename T = void>
-  struct bitset_constants
-  {
-    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
-  };
+  //namespace private_bitset
+  //{
+  //  //***************************************************************************
+  //  /// Common definitions for etl::bitset_impl
+  //  ///\ingroup bitset
+  //  //***************************************************************************
+  //  template <typename TElement>
+  //  struct bitset_impl_common
+  //  {
+  //    typedef TElement            element_type;
+  //    typedef element_type* pointer;
+  //    typedef const element_type* const_pointer;
 
-  template <typename T>
-  ETL_CONSTANT size_t bitset_constants<T>::npos;
+  //    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
+
+  //    static ETL_CONSTANT size_t       Bits_Per_Element  = etl::integral_limits<element_type>::bits;
+  //    static ETL_CONSTANT element_type All_Set_Element   = etl::integral_limits<element_type>::max;
+  //    static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
+  //  };
+
+  //  template <typename TElement>
+  //  ETL_CONSTANT size_t bitset_impl_common<TElement>::npos;
+
+  //  template <typename TElement>
+  //  ETL_CONSTANT size_t bitset_impl_common<TElement>::Bits_Per_Element;
+
+  //  template <typename TElement>
+  //  ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Set_Element;
+
+  //  template <typename TElement>
+  //  ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Clear_Element;
+
+  //  //***************************************************************************
+  //  /// Common definitions for etl::bitset
+  //  ///\ingroup bitset
+  //  //***************************************************************************
+  //  template <size_t Active_Bits, typename TElement>
+  //  struct bitset_common : public bitset_impl_common<TElement>
+  //  {
+  //    typedef TElement element_type;
+
+  //    static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
+  //    static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
+  //    static ETL_CONSTANT size_t       Top_Mask_Shift     = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
+  //    static ETL_CONSTANT element_type Top_Mask           = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+
+  //    static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
+
+  //    typedef etl::span<element_type, Number_Of_Elements>       span_type;
+  //    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
+  //  };
+
+  //  template <size_t Active_Bits, typename TElement>
+  //  ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Number_Of_Elements;
+
+  //  template <size_t Active_Bits, typename TElement>
+  //  ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Allocated_Bits;
+
+  //  template <size_t Active_Bits, typename TElement>
+  //  ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Top_Mask_Shift;
+
+  //  template <size_t Active_Bits, typename TElement>
+  //  ETL_CONSTANT typename bitset_common<Active_Bits, TElement>::element_type private_bitset::bitset_common<Active_Bits, TElement>::Top_Mask;
+  //}
+
+  //***************************************************************************
+  /// Flags to indicate whether the bitset is contained in a single element
+  /// or spread over an array of elements.
+  ///\ingroup bitset
+  //***************************************************************************
+  struct bitset_layout
+  {
+    static ETL_CONSTANT bool Single = true;
+    static ETL_CONSTANT bool Multi  = false;
+  };
 
   //***************************************************************************
   /// Exception base for bitset
@@ -142,23 +209,685 @@ namespace etl
   };
 
   //*************************************************************************
-  /// The implementation class for multi-element etl::bitset
+  /// Bitset implementation declaration.
+  ///\ingroup bitset
+  //*************************************************************************
+  template <typename TElement, bool Bitset_Layout>
+  class bitset_impl;
+
+  //*************************************************************************
+  /// The implementation class for single element etl::bitset
   ///\ingroup bitset
   //*************************************************************************
   template <typename TElement>
-  class bitset_impl : public bitset_constants<>
+  class bitset_impl<TElement, etl::bitset_layout::Single>
   {
   public:
 
-    typedef typename etl::make_unsigned<TElement>::type element_type;
+    //static ETL_CONSTANT bool Element_Layout = etl::bitset_layout::Single;
 
+    typedef TElement            element_type;
     typedef element_type*       pointer;
     typedef const element_type* const_pointer;
 
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
+    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
 
+    static ETL_CONSTANT size_t       Bits_Per_Element = etl::integral_limits<element_type>::bits;
+    static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits<element_type>::max;
+    static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
+
+    //*************************************************************************
+    /// Set all of the bits.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void set(pointer pbuffer, 
+             size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *pbuffer = All_Set_Element;
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void set(pointer pbuffer, 
+             size_t  /*number_of_elements*/, 
+             size_t  position, 
+             bool    value = true)
+    {
+      const element_type mask = element_type(element_type(1) << position);
+
+      if (value == true)
+      {
+        *pbuffer |= mask;
+      }
+      else
+      {
+        *pbuffer &= ~mask;
+      }
+    }
+
+    //*************************************************************************
+    /// Reset all of the bits.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void reset(pointer pbuffer, 
+               size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *pbuffer = All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Reset the bit at the position.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void reset(pointer pbuffer, 
+               size_t  /*number_of_elements*/, 
+               size_t  position)
+    {
+      const element_type mask = element_type(element_type(1) << position);
+      *pbuffer &= ~mask;
+    }
+
+    //*************************************************************************
+    /// Set from a string.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static 
+    void from_string(pointer     pbuffer, 
+                     size_t      /*number_of_elements*/, 
+                     size_t      active_bits, 
+                     const char* text) ETL_NOEXCEPT
+    {
+      if (text == ETL_NULLPTR)
+      {
+        reset(pbuffer, 1U);
+      }
+      else
+      {
+        size_t string_length = etl::strlen(text);
+
+        // Build from the string.
+        string_length = etl::min(active_bits, string_length);
+
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
+        {
+          if (text[i] == ETL_STR('1'))
+          {
+            *pbuffer |= mask;
+          }
+          else
+          {
+            *pbuffer &= ~mask;
+          }
+
+          mask >>= 1U;
+        }
+      }
+    }
+
+    //*************************************************************************
+    /// Set from a wide string.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static 
+    void from_string(pointer        pbuffer, 
+                     size_t         /*number_of_elements*/, 
+                     size_t         active_bits, 
+                     const wchar_t* text) ETL_NOEXCEPT
+    {
+      if (text == ETL_NULLPTR)
+      {
+        reset(pbuffer, 1U);
+      }
+      else
+      {
+        size_t string_length = etl::strlen(text);
+
+        // Build from the string.
+        string_length = etl::min(active_bits, string_length);
+
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
+        {
+          if (text[i] == ETL_STRL('1'))
+          {
+            *pbuffer |= mask;
+          }
+          else
+          {
+            *pbuffer &= ~mask;
+          }
+
+          mask >>= 1U;
+        }
+      }
+    }
+
+    //*************************************************************************
+    /// Set from a u16 string.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static 
+    void from_string(pointer         pbuffer, 
+                     size_t          /*number_of_elements*/, 
+                     size_t          active_bits, 
+                     const char16_t* text) ETL_NOEXCEPT
+    {
+      if (text == ETL_NULLPTR)
+      {
+        reset(pbuffer, 1U);
+      }
+      else
+      {
+        size_t string_length = etl::strlen(text);
+
+        // Build from the string.
+        string_length = etl::min(active_bits, string_length);
+
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
+        {
+          if (text[i] == ETL_STRu('1'))
+          {
+            *pbuffer |= mask;
+          }
+          else
+          {
+            *pbuffer &= ~mask;
+          }
+
+          mask >>= 1U;
+        }
+      }
+    }
+
+    //*************************************************************************
+    /// Set from a u32 string.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void from_string(pointer         pbuffer, 
+                     size_t          /*number_of_elements*/, 
+                     size_t          active_bits, 
+                     const char32_t* text) ETL_NOEXCEPT
+    {
+      if (text == ETL_NULLPTR)
+      {
+        reset(pbuffer, 1U);
+      }
+      else
+      {
+        size_t string_length = etl::strlen(text);
+
+        // Build from the string.
+        string_length = etl::min(active_bits, string_length);
+
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
+        {
+          if (text[i] == ETL_STRU('1'))
+          {
+            *pbuffer |= mask;
+          }
+          else
+          {
+            *pbuffer &= ~mask;
+          }
+
+          mask >>= 1U;
+        }
+      }
+    }
+
+    //*************************************************************************
+    /// Get as an integral value.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    static
+    T value(const_pointer pbuffer, 
+            size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return T(*pbuffer);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    static
+    T extract(const_pointer pbuffer, 
+              size_t        position, 
+              size_t        length = etl::integral_limits<T>::bits)
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      const unsigned_t Mask  = etl::make_lsb_mask<unsigned_t>(length);
+      const unsigned_t Shift = position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
+    }
+
+    //*************************************************************************
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will return <b>false</b>.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool test(const_pointer pbuffer, 
+              size_t        /*number_of_elements*/, 
+              size_t        position)
+    {
+      const element_type mask = element_type(element_type(1) << position);
+      return (*pbuffer & mask) != 0U;
+    }
+
+    //*************************************************************************
+    /// Count the number of bits set.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    size_t count(const_pointer pbuffer, 
+                 size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return etl::count_bits(*pbuffer);
+    }
+
+    //*************************************************************************
+    // Are all the bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    bool all(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/, 
+             element_type  top_mask) ETL_NOEXCEPT
+    {
+      return (*pbuffer & top_mask) == top_mask;
+    }
+
+    //*************************************************************************
+    // Are all the mask bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool all(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/, 
+             element_type  top_mask, 
+             element_type  mask) ETL_NOEXCEPT
+    {
+      return (*pbuffer & top_mask & mask) == mask;
+    }
+
+    //*************************************************************************
+    /// Are none of the bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool none(const_pointer pbuffer, 
+              size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return *pbuffer == All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Are none of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool none(const_pointer pbuffer, 
+              size_t        /*number_of_elements*/, 
+              element_type  mask) ETL_NOEXCEPT
+    {
+      return (*pbuffer & mask) == All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Are any of the bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool any(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return *pbuffer != All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Are any of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool any(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/, 
+             element_type  mask) ETL_NOEXCEPT
+    {
+      return (*pbuffer & mask) != All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Flip all of the bits.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void flip(pointer pbuffer, 
+              size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *pbuffer = ~*pbuffer;
+    }
+
+    //*************************************************************************
+    /// Flip some of the bits.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void flip_bits(pointer      pbuffer, 
+                   size_t       /*number_of_elements*/, 
+                   element_type mask = etl::integral_limits<element_type>::max) ETL_NOEXCEPT
+    {
+      *pbuffer ^= mask;
+    }
+
+    //*************************************************************************
+    /// Flip the bit at the position.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void flip(pointer pbuffer, 
+              size_t  /*number_of_elements*/, 
+              size_t  position)
+    {
+      const element_type mask = element_type(element_type(1) << position);
+      *pbuffer ^= mask;
+    }
+
+    //*************************************************************************
+    /// Read [] operator.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool read_bit(const_pointer pbuffer, 
+                  size_t        active_bits, 
+                  size_t        /*number_of_elements*/, 
+                  size_t        position) ETL_NOEXCEPT
+    {
+      if (position < active_bits)
+      {
+        const element_type mask = element_type(element_type(1) << position);
+        return (*pbuffer & mask) != 0U;
+      }
+
+      return false;
+    }
+
+    //*************************************************************************
+    /// Write [] operator.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void write_bit(pointer pbuffer, 
+                   size_t  /*number_of_elements*/, 
+                   size_t  position) ETL_NOEXCEPT
+    {
+      return bit_reference(*this, position);
+    }
+
+    //*************************************************************************
+    /// Returns a string representing the bitset.
+    //*************************************************************************
+#if ETL_USING_CPP11
+    template <typename TString = etl::string<Active_Bits>>
+#else
+    template <typename TString>
+#endif
+    ETL_CONSTEXPR14 
+    static 
+    TString to_string(const_pointer pbuffer,
+                      size_t /*number_of_elements*/,
+                      size_t active_bits,
+                      typename TString::value_type zero = typename TString::value_type('0'),
+                      typename TString::value_type one  = typename TString::value_type('1'))
+    {
+      TString result;
+
+      result.resize(active_bits, '\0');
+
+      // Check that the string type can contain the digits.
+      ETL_ASSERT_OR_RETURN_VALUE(result.size() == active_bits, ETL_ERROR(etl::bitset_string_too_small), result);
+
+      for (size_t i = active_bits; i > 0; --i)
+      {
+        result[active_bits - i] = test(pbuffer, 0, i - 1) ? one : zero;
+      }
+
+      return result;
+    }
+
+    //*************************************************************************
+    /// Finds the next bit in the specified state.
+    ///\param state    The state to search for.
+    ///\param position The position to start from.
+    ///\returns The position of the bit or npos if none were found.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    size_t find_next(const_pointer pbuffer, 
+                     size_t        /*number_of_elements*/, 
+                     size_t        active_bits, 
+                     bool          state, 
+                     size_t        position) ETL_NOEXCEPT
+    {
+      if (position < active_bits)
+      {
+        // Where to start.
+        size_t bit = position;
+
+        element_type mask = 1U << position;
+
+        // Needs checking?
+        if ((state && (*pbuffer != All_Clear_Element)) || (!state && (*pbuffer != All_Set_Element)))
+        {
+          // For each bit in the element...
+          while (bit < active_bits)
+          {
+            // Equal to the required state?
+            if (((*pbuffer & mask) != 0) == state)
+            {
+              return bit;
+            }
+
+            // Move on to the next bit.
+            mask <<= 1;
+            ++bit;
+          }
+        }
+      }
+
+      return npos;
+    }
+
+    //*************************************************************************
+    /// operator assignment
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_assignment(pointer       lhs_pbuffer, 
+                             const_pointer rhs_pbuffer, 
+                             size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer = *rhs_pbuffer;
+    }
+
+    //*************************************************************************
+    /// operator and
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_and(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer &= *rhs_pbuffer;
+    }
+
+    //*************************************************************************
+    /// operator or
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_or(pointer       lhs_pbuffer, 
+                     const_pointer rhs_pbuffer, 
+                     size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer |= *rhs_pbuffer;
+    }
+
+    //*************************************************************************
+    /// operator xor
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_xor(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer ^= *rhs_pbuffer;
+    }
+
+    //*************************************************************************
+    /// operator ~
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_not(pointer pbuffer, 
+                      size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *pbuffer = ~*pbuffer;
+    }
+
+    //*************************************************************************
+    /// operator_shift_left
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_shift_left(pointer pbuffer, 
+                             size_t  /*number_of_elements*/, 
+                             size_t  active_bits, 
+                             size_t  shift) ETL_NOEXCEPT
+    {
+      if (shift >= active_bits)
+      {
+        reset(pbuffer, 1U);
+      }
+      else
+      {
+        *pbuffer <<= shift;
+      }
+    }
+
+    //*************************************************************************
+    /// operator_shift_right
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_shift_right(pointer pbuffer, 
+                              size_t  /*number_of_elements*/, 
+                              size_t  active_bits, 
+                              size_t  shift) ETL_NOEXCEPT
+    {
+      if (shift >= active_bits)
+      {
+        reset(pbuffer, 1U);
+      }
+      else
+      {
+        *pbuffer >>= shift;
+      }
+    }
+
+    //*************************************************************************
+    /// operator_equality
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static
+    bool operator_equality(const_pointer lhs_pbuffer, 
+                           const_pointer rhs_pbuffer, 
+                           size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return (*lhs_pbuffer == *rhs_pbuffer);
+    }
+
+    //*************************************************************************
+    /// Initialise from an unsigned long long.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void initialise(pointer            pbuffer, 
+                    size_t             /*number_of_elements*/,
+                    unsigned long long value) ETL_NOEXCEPT
+    {
+      *pbuffer = static_cast<element_type>(value);
+    }
+
+    //*************************************************************************
+    /// swap
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static
+    void swap(pointer lhs_pbuffer, 
+              pointer rhs_pbuffer, 
+              size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      using ETL_OR_STD::iter_swap;
+
+      iter_swap(lhs_pbuffer, rhs_pbuffer);
+    }
+  };
+
+  //template <typename TElement>
+  //ETL_CONSTANT bool etl::bitset_impl<TElement, etl::bitset_layout::Single>::Element_Layout;
+
+  //*************************************************************************
+  /// The implementation class for multi element etl::bitset
+  ///\ingroup bitset
+  //*************************************************************************
+  template <typename TElement>
+  class bitset_impl<TElement, etl::bitset_layout::Multi>
+  {
+  public:
+
+    typedef TElement            element_type;
+    typedef element_type*       pointer;
+    typedef const element_type* const_pointer;
+
+    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
+
+    static ETL_CONSTANT size_t       Bits_Per_Element = etl::integral_limits<element_type>::bits;
+    static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits<element_type>::max;
+    static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
+
+    //static ETL_CONSTANT bool Element_Layout = etl::bitset_layout::Multi;
+
+    //*************************************************************************
+    /// Check to see if the requested extract is contained within one element.
+    //*************************************************************************
     template <size_t Position, size_t Length, size_t Bits_Per_Element>
     struct value_is_in_one_element
     {
@@ -168,7 +897,10 @@ namespace etl
     //*************************************************************************
     /// Count the number of bits set.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t count(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 
+    static 
+    size_t count(const_pointer pbuffer, 
+                 size_t        number_of_elements) ETL_NOEXCEPT
     {
       size_t n = 0UL;
 
@@ -184,7 +916,11 @@ namespace etl
     /// Tests a bit at a position.
     /// Positions greater than the number of configured bits will return <b>false</b>.
     //*************************************************************************
-    ETL_CONSTEXPR14 bool test(const_pointer pbuffer, size_t number_of_elements, size_t position) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 
+    static
+    bool test(const_pointer pbuffer, 
+              size_t        number_of_elements, 
+              size_t        position) ETL_NOEXCEPT
     {
       size_t       index = 0U;
       element_type mask  = element_type(0);
@@ -207,7 +943,12 @@ namespace etl
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t position, bool value = true) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void set(pointer pbuffer, 
+             size_t  number_of_elements, 
+             size_t  position, 
+             bool    value = true) ETL_NOEXCEPT
     {
       size_t    index = 0;
       element_type bit = 0;
@@ -240,7 +981,12 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 
+    static 
+    void from_string(pointer     pbuffer, 
+                     size_t      number_of_elements, 
+                     size_t      total_bits, 
+                     const char* text) ETL_NOEXCEPT
     {
       if (text == ETL_NULLPTR)
       {
@@ -270,7 +1016,12 @@ namespace etl
     //*************************************************************************
     /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const wchar_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void from_string(pointer        pbuffer, 
+                     size_t         number_of_elements, 
+                     size_t         total_bits, 
+                     const wchar_t* text) ETL_NOEXCEPT
     {
       if (text == ETL_NULLPTR)
       {
@@ -300,7 +1051,12 @@ namespace etl
     //*************************************************************************
     /// Set from a u16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void from_string(pointer         pbuffer, 
+                     size_t          number_of_elements, 
+                     size_t          total_bits, 
+                     const char16_t* text) ETL_NOEXCEPT
     {
       if (text == ETL_NULLPTR)
       {
@@ -330,7 +1086,12 @@ namespace etl
     //*************************************************************************
     /// Set from a u32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void from_string(pointer         pbuffer, 
+                     size_t          number_of_elements, 
+                     size_t          total_bits, 
+                     const char32_t* text) ETL_NOEXCEPT
     {
       if (text == ETL_NULLPTR)
       {
@@ -360,7 +1121,12 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 
+    static 
+    void set(pointer     pbuffer, 
+             size_t      number_of_elements, 
+             size_t      total_bits, 
+             const char* text) ETL_NOEXCEPT
     {
       from_string(pbuffer, number_of_elements, total_bits, text);
     }
@@ -368,7 +1134,12 @@ namespace etl
     //*************************************************************************
     /// Set from a wstring.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const wchar_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void set(pointer        pbuffer, 
+             size_t         number_of_elements, 
+             size_t         total_bits, 
+             const wchar_t* text) ETL_NOEXCEPT
     {
       from_string(pbuffer, number_of_elements, total_bits, text);
     }
@@ -376,7 +1147,12 @@ namespace etl
     //*************************************************************************
     /// Set from a u16string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void set(pointer         pbuffer, 
+             size_t          number_of_elements, 
+             size_t          total_bits, 
+             const char16_t* text) ETL_NOEXCEPT
     {
       from_string(pbuffer, number_of_elements, total_bits, text);
     }
@@ -384,18 +1160,53 @@ namespace etl
     //*************************************************************************
     /// Set from a u32string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void set(pointer         pbuffer, 
+             size_t          number_of_elements, 
+             size_t          total_bits, 
+             const char32_t* text) ETL_NOEXCEPT
     {
       from_string(pbuffer, number_of_elements, total_bits, text);
     }
 
+    //*************************************************************************
+    /// Reset all of the bits.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void reset(pointer pbuffer, 
+               size_t  number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0U)
+      {
+        *pbuffer++ = All_Clear_Element;
+      }
+    }
+
+    //*************************************************************************
+    /// Reset the bit at the position.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void reset(pointer pbuffer, 
+               size_t  number_of_elements, 
+               size_t  position) ETL_NOEXCEPT
+    {
+      const size_t       index = position >> etl::log2<Bits_Per_Element>::value;;
+      const element_type bit = element_type(1) << (position & (Bits_Per_Element - 1));
+
+      pbuffer[index] &= ~bit;
+    }
+
     //*************************************************************************
     /// Get as a value.
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT
+    static
+    T value(const_pointer pbuffer, 
+            size_t        number_of_elements) ETL_NOEXCEPT
     {
       T v = T(0);
 
@@ -420,10 +1231,11 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
+    static 
     typename etl::make_unsigned<T>::type extract_from_multiple_elements(const element_type* pbuffer,
                                                                         int                 element_index,
                                                                         size_t              active_bits_in_msb,
-                                                                        size_t              length) const ETL_NOEXCEPT
+                                                                        size_t              length) ETL_NOEXCEPT
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
@@ -470,7 +1282,10 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    typename etl::make_unsigned<T>::type extract_from_buffer(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT
+    static
+    typename etl::make_unsigned<T>::type extract_from_buffer(const_pointer pbuffer, 
+                                                             size_t        position, 
+                                                             size_t        length) ETL_NOEXCEPT
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
@@ -502,12 +1317,13 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value when the value fits in one element.
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
+    static
     typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
-      extract_from_buffer(const_pointer pbuffer) const
+      extract_from_buffer(const_pointer pbuffer)
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
@@ -519,12 +1335,13 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value when the value spans more than one element.
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
+    static
     typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
-      extract_from_buffer(const_pointer pbuffer) const
+      extract_from_buffer(const_pointer pbuffer)
     {      
       const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
 
@@ -540,65 +1357,28 @@ namespace etl
       return extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
     }
 
-    //*************************************************************************
-    /// Reset the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 void reset(pointer pbuffer, size_t number_of_elements, size_t position) ETL_NOEXCEPT
-    {
-      size_t       index = 0U;
-      element_type bit = element_type(0);
-
-      if (number_of_elements == 0) ETL_UNLIKELY
-      {
-        return;
-      }
-      else if (number_of_elements == 1)
-      {
-        index = 0;
-        bit = element_type(1) << position;
-      }
-      else
-      {
-        index = position >> etl::log2<Bits_Per_Element>::value;
-        bit = element_type(1) << (position & (Bits_Per_Element - 1));
-      }
-
-      pbuffer[index] &= ~bit;
-    }
-
     //*************************************************************************
     /// Flip all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 void flip(pointer pbuffer, size_t number_of_elements) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void flip(pointer pbuffer, 
+              size_t  number_of_elements) ETL_NOEXCEPT
     {
-      etl::transform_n(pbuffer,
-                       number_of_elements,
-                       pbuffer, 
-                       etl::binary_not<element_type>());
+      operator_not(pbuffer, number_of_elements);
     }
 
     //*************************************************************************
     /// Flip the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 void flip(pointer pbuffer, size_t number_of_elements, size_t position) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void flip(pointer pbuffer, 
+              size_t  number_of_elements, 
+              size_t  position) ETL_NOEXCEPT
     {
-      size_t       index = 0U;
-      element_type bit = element_type(0);
-      
-      if (number_of_elements == 0) ETL_UNLIKELY
-      {
-        return;
-      }
-      else if (number_of_elements == 1)
-      {
-        index = 0;
-        bit = element_type(1) << position;
-      }
-      else
-      {
-        index = position >> log2<Bits_Per_Element>::value;
-        bit = element_type(1) << (position & (Bits_Per_Element - 1));
-      }
+      const size_t       index = position >> etl::log2<Bits_Per_Element>::value;;
+      const element_type bit   = element_type(1) << (position & (Bits_Per_Element - 1));
 
       pbuffer[index] ^= bit;
     }
@@ -606,13 +1386,12 @@ namespace etl
     //*************************************************************************
     // Are all the bits sets?
     //*************************************************************************
-    ETL_CONSTEXPR14 bool all(const_pointer pbuffer, size_t number_of_elements, element_type top_mask) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    bool all(const_pointer pbuffer, 
+             size_t        number_of_elements, 
+             element_type  top_mask) ETL_NOEXCEPT
     {
-      if (number_of_elements == 0UL)
-      {
-        return true;
-      }
-
       // All but the last.
       for (size_t i = 0UL; i < (number_of_elements - 1U); ++i)
       {
@@ -634,7 +1413,10 @@ namespace etl
     //*************************************************************************
     /// Are none of the bits set?
     //*************************************************************************
-    ETL_CONSTEXPR14 bool none(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    bool none(const_pointer pbuffer, 
+              size_t        number_of_elements) ETL_NOEXCEPT
     {
       for (size_t i = 0UL; i < number_of_elements; ++i)
       {
@@ -647,23 +1429,19 @@ namespace etl
       return true;
     }
 
-    //*************************************************************************
-    /// Finds the first bit in the specified state.
-    ///\param state The state to search for.
-    ///\returns The position of the bit or Number_Of_Elements if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_first(const_pointer pbuffer, size_t number_of_elements, size_t total_bits, bool state) const ETL_NOEXCEPT
-    {
-      return find_next(pbuffer, number_of_elements, total_bits, state, 0);
-    }
-
     //*************************************************************************
     /// Finds the next bit in the specified state.
     ///\param state    The state to search for.
     ///\param position The position to start from.
     ///\returns The position of the bit or npos if none were found.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_next(const_pointer pbuffer, size_t number_of_elements, size_t total_bits, bool state, size_t position) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    size_t find_next(const_pointer pbuffer, 
+                     size_t        number_of_elements, 
+                     size_t        total_bits, 
+                     bool          state, 
+                     size_t        position) ETL_NOEXCEPT
     {
       // Where to start.
       size_t index = position >> log2<Bits_Per_Element>::value;
@@ -714,11 +1492,13 @@ namespace etl
     /// Returns a string representing the bitset.
     //*************************************************************************
     template <typename TString>
-    ETL_CONSTEXPR14 TString to_string(const_pointer                pbuffer,
-                                      size_t                       number_of_elements, 
-                                      size_t                       active_bits, 
-                                      typename TString::value_type zero, 
-                                      typename TString::value_type one) const
+    ETL_CONSTEXPR14
+    static
+    TString to_string(const_pointer                pbuffer,
+                      size_t                       number_of_elements, 
+                      size_t                       active_bits, 
+                      typename TString::value_type zero, 
+                      typename TString::value_type one)
     {
       TString result;
 
@@ -736,249 +1516,265 @@ namespace etl
     }
 
     //*************************************************************************
-    /// shift_left_equals
+    /// operator assignment
     //*************************************************************************
-    ETL_CONSTEXPR14 void shift_left_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void operator_assignment(pointer       lhs_pbuffer, 
+                             const_pointer rhs_pbuffer, 
+                             size_t        number_of_elements) ETL_NOEXCEPT
     {
-      if (number_of_elements == 1U)
+      while (number_of_elements != 0)
       {
-        // Just one element.
-        pbuffer[0] <<= shift;
+        *lhs_pbuffer++ = *rhs_pbuffer++;
       }
-      else if ((shift % Bits_Per_Element) == 0U)
+    }
+
+    //*************************************************************************
+    /// operator and
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void operator_and(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0)
       {
-        // Shift by whole element.
-        const size_t element_shift = shift / Bits_Per_Element;
-        etl::copy_backward(pbuffer, pbuffer + number_of_elements - element_shift, pbuffer + number_of_elements);
-        etl::fill_n(pbuffer, element_shift, All_Clear_Element);
+        *lhs_pbuffer++ &= *rhs_pbuffer++;
       }
-      else
+    }
+
+    //*************************************************************************
+    /// operator or
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void operator_or(pointer       lhs_pbuffer, 
+                     const_pointer rhs_pbuffer, 
+                     size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0)
       {
-        // The place where the elements are split when shifting.
-        const size_t split_position = Bits_Per_Element - (shift % Bits_Per_Element);
+        *lhs_pbuffer++ != *rhs_pbuffer++;
+      }
+    }
 
-        // Where we are shifting from.
-        int src_index = int(number_of_elements - (shift / Bits_Per_Element) - 1U);
+    //*************************************************************************
+    /// operator xor
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void operator_xor(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0)
+      {
+        *lhs_pbuffer++ ^= *rhs_pbuffer++;
+      }
+    }
 
-        // Where we are shifting to.
-        int dst_index = int(number_of_elements - 1U);
+    //*************************************************************************
+    /// operator not
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void operator_not(pointer pbuffer, 
+                      size_t  number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0)
+      {
+        *pbuffer++ = ~*pbuffer++;
+      }
+    }
 
-        // Shift control constants.
-        const size_t lsb_shift = Bits_Per_Element - split_position;
-        const size_t msb_shift = split_position;
+    //*************************************************************************
+    /// operator_shift_left
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void operator_shift_left(pointer pbuffer, 
+                             size_t  number_of_elements, 
+                             size_t  active_bits, 
+                             size_t  shift) ETL_NOEXCEPT
+    {
+      // The place where the elements are split when shifting.
+      const size_t split_position = Bits_Per_Element - (shift % Bits_Per_Element);
 
-        const element_type lsb_mask         = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
-        const element_type msb_mask         = etl::integral_limits<element_type>::max - lsb_mask;
-        const element_type lsb_shifted_mask = element_type(lsb_mask << lsb_shift);
-          
-        // First lsb.
+      // Where we are shifting from.
+      int src_index = int(number_of_elements - (shift / Bits_Per_Element) - 1U);
+
+      // Where we are shifting to.
+      int dst_index = int(number_of_elements - 1U);
+
+      // Shift control constants.
+      const size_t lsb_shift = Bits_Per_Element - split_position;
+      const size_t msb_shift = split_position;
+
+      const element_type lsb_mask = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
+      const element_type msb_mask = etl::integral_limits<element_type>::max - lsb_mask;
+      const element_type lsb_shifted_mask = element_type(lsb_mask << lsb_shift);
+
+      // First lsb.
+      element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
+      pbuffer[dst_index] = lsb;
+      --src_index;
+
+      // Now do the shifting.
+      while (src_index >= 0)
+      {
+        // Shift msb.
+        element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
+        pbuffer[dst_index] = pbuffer[dst_index] | msb;
+        --dst_index;
+
+        // Shift lsb.
         element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
         pbuffer[dst_index] = lsb;
         --src_index;
+      }
 
-        // Now do the shifting.
-        while (src_index >= 0)
-        {
-          // Shift msb.
-          element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
-          pbuffer[dst_index] = pbuffer[dst_index] | msb;
-          --dst_index;
+      // Clear the remaining bits.
+      // First lsb.
+      pbuffer[dst_index] &= lsb_shifted_mask;
 
-          // Shift lsb.
-          element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
-          pbuffer[dst_index] = lsb;
-          --src_index;
-        }
-
-        // Clear the remaining bits.
-        // First lsb.
-        pbuffer[dst_index] &= lsb_shifted_mask;
-//        --dst_index;
-
-        // The other remaining bytes on the right.
-        for (int i = 0; i < dst_index; ++i)
-        {
-          pbuffer[i] = 0;
-        }
+      // The other remaining bytes on the right.
+      for (int i = 0; i < dst_index; ++i)
+      {
+        pbuffer[i] = 0;
       }
     }
 
     //*************************************************************************
-    /// shift_right_equals
+    /// operator_shift_right
     //*************************************************************************
-    ETL_CONSTEXPR14 void shift_right_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void operator_shift_right(pointer pbuffer, 
+                              size_t  number_of_elements, 
+                              size_t  active_bits, 
+                              size_t  shift) ETL_NOEXCEPT
     {
-      if (number_of_elements == 1U)
+      // The place where the elements are split when shifting.
+      const size_t split_position = shift % Bits_Per_Element;
+
+      // Where we are shifting from.
+      int src_index = int(shift / Bits_Per_Element);
+
+      // Where we are shifting to.
+      int dst_index = 0;
+
+      // Shift control constants.
+      const size_t lsb_shift = Bits_Per_Element - split_position;
+      const size_t msb_shift = split_position;
+
+      const element_type lsb_mask = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
+      const element_type msb_mask = etl::integral_limits<element_type>::max - lsb_mask;
+      const element_type msb_shifted_mask = element_type(msb_mask >> msb_shift);
+
+      // Now do the shifting.
+      while (src_index < int(number_of_elements - 1))
       {
-        // Just one element.
-        pbuffer[0] >>= shift;
-      }
-      else if ((shift % Bits_Per_Element) == 0U)
-      {
-        // Shift by whole elements.
-        const size_t element_shift = (shift / Bits_Per_Element);
-        pointer pzeros_begin = etl::copy(pbuffer + element_shift, pbuffer + number_of_elements, pbuffer);      
-        etl::fill_n(pzeros_begin, element_shift, All_Clear_Element);
-      }
-      else
-      {
-        // The place where the elements are split when shifting.
-        const size_t split_position = shift % Bits_Per_Element;
-
-        // Where we are shifting from.
-        int src_index = int(shift / Bits_Per_Element);
-
-        // Where we are shifting to.
-        int dst_index = 0;
-
-        // Shift control constants.
-        const size_t lsb_shift = Bits_Per_Element - split_position;
-        const size_t msb_shift = split_position;
-
-        const element_type lsb_mask         = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
-        const element_type msb_mask         = etl::integral_limits<element_type>::max - lsb_mask;
-        const element_type msb_shifted_mask = element_type(msb_mask >> msb_shift);
-
-        // Now do the shifting.
-        while (src_index < int(number_of_elements - 1))
-        {
-          // Shift msb.
-          element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
-          ++src_index;
-            
-          // Shift lsb.
-          element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
-            
-          // Combine them.
-          pbuffer[dst_index] = lsb | msb;
-          ++dst_index;
-        }
-
-        // Final msb.
+        // Shift msb.
         element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
-        pbuffer[dst_index] = msb;
+        ++src_index;
 
-        // Clear the remaining bits.
-        // First msb.
-        pbuffer[dst_index] &= msb_shifted_mask;
+        // Shift lsb.
+        element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
+
+        // Combine them.
+        pbuffer[dst_index] = lsb | msb;
         ++dst_index;
+      }
 
-        // The other remaining bytes.
-        while (dst_index < int(number_of_elements))
-        {
-          pbuffer[dst_index] = 0;
-          ++dst_index;
-        }
+      // Final msb.
+      element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
+      pbuffer[dst_index] = msb;
+
+      // Clear the remaining bits.
+      // First msb.
+      pbuffer[dst_index] &= msb_shifted_mask;
+      ++dst_index;
+
+      // The other remaining bytes.
+      while (dst_index < int(number_of_elements))
+      {
+        pbuffer[dst_index] = 0;
+        ++dst_index;
       }
     }
 
     //*************************************************************************
-    /// and_equals
+    /// operator_equality
     //*************************************************************************
-    ETL_CONSTEXPR14 void and_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    bool operator_equality(const_pointer lhs_pbuffer, 
+                           const_pointer rhs_pbuffer, 
+                           size_t        number_of_elements) ETL_NOEXCEPT
     {
-      for (size_t i = 0U; i < number_of_elements; ++i)
-      {
-        pbuffer[i] &= pbuffer2[i];
-      }
-    }
-
-    //*************************************************************************
-    /// or_equals
-    //*************************************************************************
-    ETL_CONSTEXPR14 void or_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT
-    {
-      for (size_t i = 0U; i < number_of_elements; ++i)
-      {
-        pbuffer[i] |= pbuffer2[i];
-      }
-    }
-
-    //*************************************************************************
-    /// xor_equals
-    //*************************************************************************
-    ETL_CONSTEXPR14 void xor_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT
-    {
-      for (size_t i = 0U; i < number_of_elements; ++i)
-      {
-        pbuffer[i] ^= pbuffer2[i];
-      }
+      return etl::equal(lhs_pbuffer, lhs_pbuffer + number_of_elements, rhs_pbuffer);
     }
 
     //*************************************************************************
     /// Initialise from an unsigned long long.
     //*************************************************************************
-    ETL_CONSTEXPR14 void initialise(pointer pbuffer, size_t number_of_elements, unsigned long long value) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void initialise(pointer            pbuffer, 
+                    size_t             number_of_elements, 
+                    unsigned long long value) ETL_NOEXCEPT
     {
-      const size_t Shift = (etl::integral_limits<unsigned long long>::bits <= (int)Bits_Per_Element) ? 0 : Bits_Per_Element;
+      size_t i = 0UL;
+      const size_t Shift = etl::integral_limits<element_type>::bits;
 
-      // Can we do it in one hit?
-      if (Shift == 0)
+      // Set the non-zero elements.
+      while ((value != 0) && (i != number_of_elements))
       {
-        pbuffer[0] = element_type(value);
+        pbuffer[i++] = value & All_Set_Element;
+        value = value >> Shift;
       }
-      else
+
+      // Clear the remaining elements.
+      while (i != number_of_elements)
       {
-        size_t i = 0UL;
-
-        // Set the non-zero elements.
-        while ((value != 0) && (i != number_of_elements))
-        {
-          pbuffer[i++] = value & All_Set_Element;
-          value = value >> Shift;
-        }
-
-        // Clear the remaining elements.
-        while (i != number_of_elements)
-        {
-          pbuffer[i++] = All_Clear_Element;
-        }
+        pbuffer[i++] = All_Clear_Element;
       }
     }
 
     //*************************************************************************
     /// Swap bitset buffers.
     //*************************************************************************
-    ETL_CONSTEXPR14 void swap(pointer pbuffer1, pointer pbuffer2, size_t number_of_elements)
+    ETL_CONSTEXPR14
+    static
+    void swap(pointer pbuffer1, 
+              pointer pbuffer2, 
+              size_t  number_of_elements)
     {
-      const pointer pbuffer1_end = pbuffer1 + number_of_elements;
-
-      while (pbuffer1 != pbuffer1_end)
-      {
-        element_type temp = *pbuffer1;
-        *pbuffer1 = *pbuffer2;
-        *pbuffer2 = temp;
-        ++pbuffer1;
-        ++pbuffer2;
-      }
+      etl::swap_ranges(pbuffer1, pbuffer1 + number_of_elements, pbuffer2);
     }
   };
- 
-  template <typename TElement>
-  ETL_CONSTANT size_t bitset_impl<TElement>::Bits_Per_Element;
 
-  template <typename TElement>
-  ETL_CONSTANT typename bitset_impl<TElement>::element_type bitset_impl<TElement>::All_Set_Element;
-
-  template <typename TElement>
-  ETL_CONSTANT typename bitset_impl<TElement>::element_type bitset_impl<TElement>::All_Clear_Element;
+  //template <typename TElement>
+  //ETL_CONSTANT bool etl::bitset_impl<TElement, etl::bitset_layout::Multi>::Element_Layout;
 
   //***************************************************************************
-  template <size_t Active_Bits = 0U,
-            typename TElement = char,
-            bool FitsInSingleElement = etl::integral_limits<TElement>::bits >= Active_Bits>
+  /// Bitset forward declaration
+  //***************************************************************************
+  template <size_t   Active_Bits = 0U,
+            typename TElement    = unsigned char>
   class bitset;
 
   //***************************************************************************
   /// Specialisation for zero bits.
-  /// Just defines 'npos'.
   //***************************************************************************
   template <>
-  class bitset<0U, char, true> : public bitset_constants<>
+  class bitset<0U, unsigned char>
   {
   public:
 
-    typedef char element_type;
+    typedef unsigned char element_type;
 
     typedef element_type*       pointer;
     typedef const element_type* const_pointer;
@@ -990,970 +1786,34 @@ namespace etl
     static ETL_CONSTANT element_type All_Clear_Element  = 0U;
     static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
     static ETL_CONSTANT element_type Top_Mask           = 0U;
+
+    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
   };
 
-  //***************************************************************************
-  /// Specialisation for zero bits.
-  //***************************************************************************
-  template <>
-  class bitset<0U, char, false> : public bitset_constants<>
-  {
-  public:
-
-    typedef char element_type;
-
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
-
-    static ETL_CONSTANT size_t       Bits_Per_Element   = 0U;
-    static ETL_CONSTANT size_t       Number_Of_Elements = 0U;
-    static ETL_CONSTANT size_t       Allocated_Bits     = 0U;
-    static ETL_CONSTANT element_type All_Set_Element    = 0U;
-    static ETL_CONSTANT element_type All_Clear_Element  = 0U;
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
-    static ETL_CONSTANT element_type Top_Mask           = 0U;
-  };
-
-  //***************************************************************************
-  /// Specialisation that uses a single element if the number of active bits
-  /// fits into the element type size.
-  //***************************************************************************
+  //*************************************************************************
+  /// The bitset top level template.
+  //*************************************************************************
   template <size_t Active_Bits, typename TElement>
-  class bitset<Active_Bits, TElement, true> : public bitset_constants<>
+  class bitset
   {
   public:
 
-    // The element type is the unsigned variant of 'TElement'.
-    typedef typename etl::make_unsigned<TElement>::type element_type;
+    ETL_STATIC_ASSERT(etl::is_unsigned<TElement>::value, "The element type must be unsigned");
 
+    typedef TElement            element_type;
     typedef element_type*       pointer;
     typedef const element_type* const_pointer;
 
+    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
+
+    //static ETL_CONSTANT bool Element_Layout = implementation::Element_Layout;
+
     static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT size_t       Number_Of_Elements = 1U;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Bits_Per_Element;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<typename etl::make_unsigned<element_type>::type>::max;
+    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
     static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
-    static ETL_CONSTANT element_type Top_Mask           = All_Set_Element;
-
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
-
-    //*************************************************************************
-    /// The reference type returned.
-    //*************************************************************************
-    class bit_reference
-    {
-    public:
-
-      friend class bitset;
-
-      //*******************************
-      /// Copy constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
-        : p_bitset(other.p_bitset)
-        , position(other.position)
-      {
-      }
-
-      //*******************************
-      /// Conversion operator.
-      //*******************************
-      ETL_CONSTEXPR14 operator bool() const ETL_NOEXCEPT
-      {
-        return p_bitset->test(position);
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (bool b) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, b);
-        return *this;
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, bool(r));
-        return *this;
-      }
-
-      //*******************************
-      /// Flip the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& flip() ETL_NOEXCEPT
-      {
-        p_bitset->flip(position);
-        return *this;
-      }
-
-      //*******************************
-      /// Return the logical inverse of the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bool operator~() const ETL_NOEXCEPT
-      {
-        return !p_bitset->test(position);
-      }
-
-    private:
-
-      //*******************************
-      /// Default constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference() ETL_NOEXCEPT
-        : p_bitset(ETL_NULLPTR)
-        , position(0)
-      {
-      }
-
-      //*******************************
-      /// Constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(bitset<Active_Bits, TElement, true>& r_bitset, size_t position_) ETL_NOEXCEPT
-        : p_bitset(&r_bitset)
-        , position(position_)
-      {
-      }
-
-      bitset<Active_Bits, TElement, true>* p_bitset; ///< The bitset.
-      size_t position; ///< The position in the bitset.
-    };
-
-    //*************************************************************************
-    /// Default constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-    }
-
-    //*************************************************************************
-    /// Copy constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-      : buffer(other.buffer)
-    {
-    }
-
-    //*************************************************************************
-    /// Construct from a value.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT
-      : buffer(element_type(value))
-    {
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const wchar_t* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char16_t* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char32_t* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Assignment operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer = other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set() ETL_NOEXCEPT
-    {
-      buffer = All_Set_Element;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(size_t position, bool value = true)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      if (value == true)
-      {
-        buffer |= mask;
-      }
-      else
-      {
-        buffer &= ~mask;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const char* text) ETL_NOEXCEPT
-    {      
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const wchar_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const char16_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const char32_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const char* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STR('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a wide string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const wchar_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRL('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a u16 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const char16_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRu('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a u32 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const char32_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRU('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Get as an integral value.
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value() const ETL_NOEXCEPT
-    {
-      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Integral type too small");
-
-      T v = T(0);
-
-      const bool OK = (sizeof(T) * CHAR_BIT) >= Bits_Per_Element;
-
-      if (OK)
-      {
-        v = T(typename etl::make_unsigned<T>::type(buffer));
-      }
-
-      return v;
-    }
-
-    //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
-      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
-
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      const unsigned_t Mask  = etl::make_lsb_mask< unsigned_t>(length);
-      const unsigned_t Shift = position % Bits_Per_Element;
-
-      unsigned_t value = static_cast<unsigned_t>(buffer >> Shift) & Mask;
-
-      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
-      {
-        value = etl::sign_extend<T>(value, length);
-      }
-
-      return static_cast<T>(value);
-    }
-
-    //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
-    //*************************************************************************
-    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
-    ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      extract() const ETL_NOEXCEPT
-    {
-      ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
-      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
-      
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      const unsigned_t Mask  = etl::make_lsb_mask<unsigned_t, Length>();
-      const unsigned_t Shift = Position % Bits_Per_Element;
-
-      unsigned_t value = static_cast<unsigned_t>(buffer >> Shift) & Mask;
-
-      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
-      {
-        value = etl::sign_extend<T, Length>(value);
-      }
-
-      return static_cast<T>(value);
-    }
-
-    //*************************************************************************
-    /// Get as an unsigned long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long>();
-    }
-
-    //*************************************************************************
-    /// Get as an unsigned long long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long long>();
-    }
-
-    //*************************************************************************
-    /// Reset all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& reset() ETL_NOEXCEPT
-    {
-      buffer = All_Clear_Element;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Reset the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& reset(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      buffer &= ~mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Tests a bit at a position.
-    /// Positions greater than the number of configured bits will return <b>false</b>.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool test(size_t position) const
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
-
-      const element_type mask = element_type(element_type(1) << position);
-      return (buffer & mask) != 0U;
-    }
-
-    //*************************************************************************
-    /// The number of bits in the bitset.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
-    {
-      return Active_Bits;
-    }
-
-    //*************************************************************************
-    /// Count the number of bits set.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
-    {
-      return etl::count_bits(buffer);
-    }
-
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
-    {
-      return buffer == All_Set_Element;
-    }
-
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
-    {
-      return buffer == (All_Set_Element & mask);
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
-    {
-      return buffer == All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
-    {
-      return (buffer & mask) == All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
-    {
-      return !none();
-    }
-
-    //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
-    {
-      return !none(mask);
-    }
-
-    //*************************************************************************
-    /// Flip all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& flip() ETL_NOEXCEPT
-    {
-      buffer = ~buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Flip some of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& flip_bits(element_type mask = etl::integral_limits<element_type>::max) ETL_NOEXCEPT
-    {
-      buffer ^= mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Flip the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& flip(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      buffer ^= mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Read [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
-    {
-      if (position < Active_Bits)
-      {
-        const element_type mask = element_type(element_type(1) << position);
-        return (buffer & mask) != 0U;
-      }
-
-      return false;
-    }
-
-    //*************************************************************************
-    /// Write [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bit_reference operator [] (size_t position) ETL_NOEXCEPT
-    {
-      return bit_reference(*this, position);
-    }
-
-    //*************************************************************************
-    /// Returns a string representing the bitset.
-    //*************************************************************************
-#if ETL_USING_CPP11
-    template <typename TString = etl::string<Active_Bits>>
-#else
-    template <typename TString>
-#endif
-    ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
-                                      typename TString::value_type one  = typename TString::value_type('1')) const
-    {
-      TString result;
-
-      result.resize(Active_Bits, '\0');
-
-      // Check that the string type can contain the digits.
-      ETL_ASSERT_OR_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result);
-
-      for (size_t i = Active_Bits; i > 0; --i)
-      {
-        result[Active_Bits - i] = test(i - 1) ? one : zero;
-      }
-
-      return result;
-    }
-
-    //*************************************************************************
-    /// Finds the first bit in the specified state.
-    ///\param state The state to search for.
-    ///\returns The position of the bit or npos if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
-    {
-      return find_next(state, 0U);
-    }
-
-    //*************************************************************************
-    /// Finds the next bit in the specified state.
-    ///\param state    The state to search for.
-    ///\param position The position to start from.
-    ///\returns The position of the bit or npos if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
-    {
-      if (position < Active_Bits)
-      {
-        // Where to start.
-        size_t bit = position;
-
-        element_type mask = 1U << position;
-
-        // Needs checking?
-        if ((state && (buffer != All_Clear_Element)) || (!state && (buffer != All_Set_Element)))
-        {
-          // For each bit in the element...
-          while (bit < Active_Bits)
-          {
-            // Equal to the required state?
-            if (((buffer & mask) != 0) == state)
-            {
-              return bit;
-            }
-
-            // Move on to the next bit.
-            mask <<= 1;
-            ++bit;
-          }
-        }
-      }
-
-      return npos;
-    }
-
-    //*************************************************************************
-    /// operator &
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator &(const bitset<Active_Bits, TElement, true>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp &= other;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator &=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator &=(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer &= other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator |
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator |(const bitset<Active_Bits, TElement, true>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp |= other;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator |=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator |=(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer |= other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ^
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator ^(const bitset<Active_Bits, TElement, true>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp ^= other;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator ^=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator ^=(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer ^= other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ~
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator ~() const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp.flip();
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator <<
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator <<(size_t shift) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp <<= shift;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator <<=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator <<=(size_t shift) ETL_NOEXCEPT
-    {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        buffer <<= shift;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator >>
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator >>(size_t shift) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement> temp(*this);
-
-      temp >>= shift;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator >>=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator >>=(size_t shift) ETL_NOEXCEPT
-    {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        buffer >>= shift;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ==
-    //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset<Active_Bits, TElement, true>& lhs, const bitset<Active_Bits, TElement, true>& rhs) ETL_NOEXCEPT
-    {
-      return (lhs.buffer == rhs.buffer);
-    }
-
-    //*************************************************************************
-    /// swap
-    //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      element_type temp = buffer;
-      buffer = other.buffer;
-      other.buffer = temp;
-    }
-
-    //*************************************************************************
-    /// span
-    /// Returns a span of the underlying buffer.
-    //*************************************************************************
-    ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT
-    {
-      return span_type(&buffer, 1);
-    }
-
-    //*************************************************************************
-    /// span
-    /// Returns a const span of the underlying buffer.
-    //*************************************************************************
-    ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT
-    {
-      return const_span_type(&buffer, 1);
-    }
-
-  private:
-
-    element_type buffer;
-  };
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Bits_Per_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Number_Of_Elements;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Allocated_Bits;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::All_Set_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::All_Clear_Element;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Top_Mask_Shift;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::Top_Mask;
-
-  //*************************************************************************
-  /// The specialisation that uses an array of the default element type.
-  //*************************************************************************
-  template <size_t Active_Bits, typename TElement>
-  class bitset<Active_Bits, TElement, false> : public bitset_constants<>
-  {
-  private:
-
-    //*************************************************************************
-    // If the 'TElement' is the default 'void', then use 'char', otherwise uses
-    // the unsigned variant of 'TElement'.
-    //*************************************************************************
-    struct select_element_type
-    {
-      typedef typename etl::make_unsigned<typename etl::conditional<etl::is_same<void, TElement>::value, char, TElement>::type>::type type;
-    };  
-
-  public:
-
-    typedef typename select_element_type::type element_type;
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
-      
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::bitset_impl<element_type>::Bits_Per_Element;
     static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
     static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
     static ETL_CONSTANT size_t       Top_Mask_Shift     = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-    static ETL_CONSTANT element_type All_Set_Element    = etl::bitset_impl<element_type>::All_Set_Element;
-    static ETL_CONSTANT element_type All_Clear_Element  = etl::bitset_impl<element_type>::All_Clear_Element;
     static ETL_CONSTANT element_type Top_Mask           = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
 
     static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
@@ -2042,7 +1902,7 @@ namespace etl
       {
       }
 
-      bitset<Active_Bits, TElement, false>* p_bitset; ///< The bitset.
+      bitset<Active_Bits, TElement>* p_bitset; ///< The bitset.
       size_t position; ///< The position in the bitset.
     };
 
@@ -2050,18 +1910,17 @@ namespace etl
     /// Default constructor.
     //*************************************************************************
     ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT
-      : buffer()
     {
-      reset();
+      implementation::reset(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Copy constructor.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
       : buffer()
     {
-      etl::copy_n(other.buffer, Number_Of_Elements, buffer);
+      implementation::operator_assignment(buffer, other.buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2070,8 +1929,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT
       : buffer()
     {
-      ibitset.initialise(buffer, Number_Of_Elements, value);
-      clear_unused_bits_in_msb();
+      implementation::initialise(buffer, Number_Of_Elements, value);
     }
 
     //*************************************************************************
@@ -2080,8 +1938,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset(const char* text) ETL_NOEXCEPT
       : buffer()
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2090,8 +1947,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset(const wchar_t* text) ETL_NOEXCEPT
       : buffer()
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2100,8 +1956,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset(const char16_t* text) ETL_NOEXCEPT
       : buffer()
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2110,14 +1965,13 @@ namespace etl
     ETL_CONSTEXPR14 bitset(const char32_t* text) ETL_NOEXCEPT
       : buffer()
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Assignment operator.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
       etl::copy_n(other.buffer, Number_Of_Elements, buffer);
 
@@ -2127,10 +1981,9 @@ namespace etl
     //*************************************************************************
     /// Set all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set() ETL_NOEXCEPT
     {
-      etl::fill_n(buffer, Number_Of_Elements, All_Set_Element);
-      clear_unused_bits_in_msb();
+      implementation::set(buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2138,12 +1991,11 @@ namespace etl
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(size_t position, bool value = true)
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(size_t position, bool value = true)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      ibitset.set(buffer, Number_Of_Elements, position, value);
-      clear_unused_bits_in_msb();
+      implementation::set(buffer, Number_Of_Elements, position, value);
       
       return *this;
     }
@@ -2151,9 +2003,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const char* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const char* text) ETL_NOEXCEPT
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2161,9 +2013,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const wchar_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const wchar_t* text) ETL_NOEXCEPT
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2171,9 +2023,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const char16_t* text) ETL_NOEXCEPT
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2181,9 +2033,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const char32_t* text) ETL_NOEXCEPT
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2191,9 +2043,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const char* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const char* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2201,9 +2053,9 @@ namespace etl
     //*************************************************************************
     /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const wchar_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const wchar_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2211,9 +2063,9 @@ namespace etl
     //*************************************************************************
     /// Set from a u16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const char16_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2221,9 +2073,9 @@ namespace etl
     //*************************************************************************
     /// Set from a u32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const char32_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2237,9 +2089,9 @@ namespace etl
       value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
+      ETL_STATIC_ASSERT(etl::integral_limits<T>::bits >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
 
-      return ibitset.template value<T>(buffer, Number_Of_Elements);
+      return implementation::template value<T>(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2247,21 +2099,14 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+    T extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
     {
-      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
 
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
+      ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
 
-      unsigned_t value = ibitset.template extract_from_buffer<T>(buffer, position, length);;
-
-      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
-      {
-        value = etl::sign_extend<T>(value, length);
-      }
-
-      return static_cast<T>(value);
+      return implementation::extract<T>(buffer, position, length);
     }
 
     //*************************************************************************
@@ -2269,21 +2114,13 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
     ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      extract() const ETL_NOEXCEPT
+    T extract() const
     {
-      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value,              "Only integral types are supported");
+      ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
 
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      unsigned_t value = ibitset.template extract_from_buffer<T, Position, Length>(buffer);
-
-      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
-      {
-        value = etl::sign_extend<T, Length>(value);
-      }
-
-      return static_cast<T>(value);
+      return implementation::extract<T>(buffer, Position, Length);
     }
 
     //*************************************************************************
@@ -2291,7 +2128,9 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
     {
-      return value<unsigned long>();
+      ETL_STATIC_ASSERT(etl::integral_limits<unsigned long>::bits >= Active_Bits, "to_ulong() : Active_Bits > unsigned long");
+
+      return implementation::template value<unsigned long>(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2299,14 +2138,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
     {
-      return value<unsigned long long>();
+      ETL_STATIC_ASSERT(etl::integral_limits<unsigned long long>::bits >= Active_Bits, "to_ullong() : Active_Bits > unsigned long long");
+
+      return implementation::template value<unsigned long long>(buffer, Number_Of_Elements);
     }
+
     //*************************************************************************
     /// Reset all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& reset() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& reset() ETL_NOEXCEPT
     {
-      etl::fill_n(buffer, Number_Of_Elements, All_Clear_Element);
+      implementation::reset(buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2314,11 +2156,11 @@ namespace etl
     //*************************************************************************
     /// Reset the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& reset(size_t position)
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& reset(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      ibitset.reset(buffer, Number_Of_Elements, position);
+      implementation::reset(buffer, Number_Of_Elements, position);
 
       return *this;
     }
@@ -2331,7 +2173,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
 
-      return ibitset.test(buffer, Number_Of_Elements, position);
+      return implementation::test(buffer, Number_Of_Elements, position);
     }
  
     //*************************************************************************
@@ -2347,7 +2189,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
     {
-      return ibitset.count(buffer, Number_Of_Elements);
+      return implementation::count(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2355,7 +2197,15 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
     {
-      return ibitset.all(buffer, Number_Of_Elements, Top_Mask);
+      return implementation::all(buffer, Number_Of_Elements, Top_Mask);
+    }
+
+    //*************************************************************************
+    // Are all the mask bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
+    {
+      return implementation::all(buffer, Number_Of_Elements, Top_Mask, mask);
     }
 
     //*************************************************************************
@@ -2363,7 +2213,15 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
     {
-      return ibitset.none(buffer, Number_Of_Elements);
+      return implementation::none(buffer, Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// Are none of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
+    {
+      return implementation::none(buffer, Number_Of_Elements, mask);
     }
 
     //*************************************************************************
@@ -2371,16 +2229,23 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
     {
-      return !none();
+      return implementation::any(buffer, Number_Of_Elements);
     }
  
+    //*************************************************************************
+    /// Are any of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
+    {
+      return implementation::any(buffer, Number_Of_Elements, mask);
+    }
+
     //*************************************************************************
     /// Flip all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& flip() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& flip() ETL_NOEXCEPT
     {
-      ibitset.flip(buffer, Number_Of_Elements);
-      clear_unused_bits_in_msb();
+      implementation::flip(buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2388,11 +2253,11 @@ namespace etl
     //*************************************************************************
     /// Flip the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& flip(size_t position)
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& flip(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      ibitset.flip(buffer, Number_Of_Elements, position);
+      implementation::flip(buffer, Number_Of_Elements, position);
 
       return *this;
     }
@@ -2402,7 +2267,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
     {
-      return ibitset.test(buffer, Number_Of_Elements, position);
+      return implementation::test(buffer, Number_Of_Elements, position);
     }
 
     //*************************************************************************
@@ -2424,7 +2289,7 @@ namespace etl
     ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
                                       typename TString::value_type one  = typename TString::value_type('1')) const
     {
-      return ibitset.template to_string<TString>(buffer, Number_Of_Elements, Active_Bits, zero, one);
+      return implementation::template to_string<TString>(buffer, Number_Of_Elements, Active_Bits, zero, one);
     }
 
     //*************************************************************************
@@ -2434,7 +2299,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
     {
-      return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, 0);
+      return implementation::find_next(buffer, Number_Of_Elements, Active_Bits, state, 0);
     }
 
     //*************************************************************************
@@ -2445,17 +2310,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
     {
-      return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, position);
+      return implementation::find_next(buffer, Number_Of_Elements, Active_Bits, state, position);
     }
 
     //*************************************************************************
     /// operator &
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator &(const bitset<Active_Bits, TElement, false>& other) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator &(const bitset<Active_Bits, TElement>& other) const ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-      temp &= other;
+      implementation::operator_and(temp.buffer, other.buffer, Number_Of_Elements);
 
       return temp;
     }
@@ -2463,9 +2328,9 @@ namespace etl
     //*************************************************************************
     /// operator &=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator &=(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator &=(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.and_equals(&buffer[0], &other.buffer[0], Number_Of_Elements);
+      implementation::operator_and(buffer, other.buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2473,11 +2338,11 @@ namespace etl
     //*************************************************************************
     /// operator |
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator |(const bitset<Active_Bits, TElement, false>& other) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator |(const bitset<Active_Bits, TElement>& other) const ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-      temp |= other;
+      implementation::operator_or(temp.buffer, other.buffer, Number_Of_Elements);
 
       return temp;
     }
@@ -2485,9 +2350,9 @@ namespace etl
     //*************************************************************************
     /// operator |=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator |=(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator |=(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.or_equals(&buffer[0], &other.buffer[0], Number_Of_Elements);
+      implementation::operator_or(&buffer[0], &other.buffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -2495,11 +2360,11 @@ namespace etl
     //*************************************************************************
     /// operator ^
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator ^(const bitset<Active_Bits, TElement, false>& other) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator ^(const bitset<Active_Bits, TElement>& other) const ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-      temp ^= other;
+      implementation::operator_xor(temp.buffer, other.buffer, Number_Of_Elements);
 
       return temp;
     }
@@ -2507,9 +2372,9 @@ namespace etl
     //*************************************************************************
     /// operator ^=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator ^=(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator ^=(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.xor_equals(&buffer[0], &other.buffer[0], Number_Of_Elements);
+      implementation::operator_xor(buffer, other.buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2517,11 +2382,11 @@ namespace etl
     //*************************************************************************
     /// operator ~
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator ~() const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator ~() const ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-      temp.flip();
+      implementation::flip(temp.buffer, Number_Of_Elements);
 
       return temp;
     }
@@ -2529,11 +2394,11 @@ namespace etl
     //*************************************************************************
     /// operator <<
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator <<(size_t shift) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator <<(size_t shift) const ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-      temp <<= shift;
+      implementation::operator_shift_left(temp.buffer, Number_Of_Elements, Active_Bits, shift);
 
       return temp;
     }
@@ -2541,16 +2406,15 @@ namespace etl
     //*************************************************************************
     /// operator <<=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator <<=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator <<=(size_t shift) ETL_NOEXCEPT
     {
       if (shift >= Active_Bits)
       {
-        reset();
+        implementation::reset(buffer, Number_Of_Elements);
       }
       else
       {
-        ibitset.shift_left_equals(buffer, Number_Of_Elements, shift);
-        clear_unused_bits_in_msb();
+        implementation::operator_shift_left(buffer, Number_Of_Elements, Active_Bits, shift);
       }
       
       return *this;
@@ -2559,11 +2423,11 @@ namespace etl
     //*************************************************************************
     /// operator >>
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator >>(size_t shift) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator >>(size_t shift) const ETL_NOEXCEPT
     {
-      bitset<Active_Bits, TElement, false> temp(*this);
+      bitset<Active_Bits, TElement> temp(*this);
 
-      temp >>= shift;
+      implementation::operator_shift_right(temp.buffer, Number_Of_Elements, Active_Bits, shift);
 
       return temp;
     }
@@ -2571,15 +2435,15 @@ namespace etl
     //*************************************************************************
     /// operator >>=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator >>=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator >>=(size_t shift) ETL_NOEXCEPT
     {
       if (shift >= Active_Bits)
       {
-        reset();
+        implementation::reset(buffer, Number_Of_Elements);
       }
       else
       {
-        ibitset.shift_right_equals(buffer, Number_Of_Elements, shift);
+        implementation::operator_shift_right(buffer, Number_Of_Elements, Active_Bits, shift);
       }
 
       return *this;
@@ -2588,7 +2452,7 @@ namespace etl
     //*************************************************************************
     /// operator ==
     //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset<Active_Bits, TElement, false>& lhs, const bitset<Active_Bits, TElement, false>& rhs) ETL_NOEXCEPT
+    friend ETL_CONSTEXPR14 bool operator ==(const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
     {
       return etl::equal(lhs.buffer, 
                         lhs.buffer + lhs.Number_Of_Elements,
@@ -2598,9 +2462,9 @@ namespace etl
     //*************************************************************************
     /// swap
     //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.swap(buffer, other.buffer, Number_Of_Elements);
+      implementation::swap(buffer, other.buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2626,43 +2490,24 @@ namespace etl
     //*************************************************************************
     /// Correct the unused top bits after bit manipulation.
     //*************************************************************************
-    ETL_CONSTEXPR14 void clear_unused_bits_in_msb() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 static void clear_unused_bits_in_msb(pointer pbuffer) ETL_NOEXCEPT
     {
       buffer[Number_Of_Elements - 1U] &= Top_Mask;
     }
 
-    etl::bitset_impl<element_type> ibitset;
+    // The implementation of the bitset functionality.
+    typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_layout::Single : etl::bitset_layout::Multi> implementation;
 
-    element_type buffer[Number_Of_Elements > 0U ? Number_Of_Elements : 1U];
+    // The storage for the bitset.
+    element_type buffer[Number_Of_Elements];
   };
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Bits_Per_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Number_Of_Elements;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Allocated_Bits;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::All_Set_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::All_Clear_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Top_Mask_Shift;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::Top_Mask;
-
   //***************************************************************************
   /// operator &
   ///\ingroup bitset
   //***************************************************************************
-  template <size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bitset<Active_Bits> operator & (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTEXPR14 bitset<Active_Bits> operator & (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
   {
     bitset<Active_Bits> temp(lhs);
     temp &= rhs;
@@ -2673,8 +2518,8 @@ namespace etl
   /// operator |
   ///\ingroup bitset
   //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bitset<Active_Bits> operator | (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+  template<size_t Active_Bits, typename TElement>
+  ETL_CONSTEXPR14 bitset<Active_Bits> operator | (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
   {
     bitset<Active_Bits> temp(lhs);
     temp |= rhs;
@@ -2685,8 +2530,8 @@ namespace etl
   /// operator ^
   ///\ingroup bitset
   //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bitset<Active_Bits> operator ^ (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+  template<size_t Active_Bits, typename TElement>
+  ETL_CONSTEXPR14 bitset<Active_Bits> operator ^ (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
   {
     bitset<Active_Bits> temp(lhs);
     temp ^= rhs;
@@ -2697,8 +2542,8 @@ namespace etl
   /// operator !=
   ///\ingroup bitset
   //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bool operator != (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+  template<size_t Active_Bits, typename TElement>
+  ETL_CONSTEXPR14 bool operator != (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
   {
     return !(lhs == rhs);
   }
@@ -2707,8 +2552,8 @@ namespace etl
 //*************************************************************************
 /// swap
 //*************************************************************************
-template <size_t Active_Bits, typename TElement, bool IsSingleElement>
-ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement, IsSingleElement>& lhs, etl::bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+template <size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement>& lhs, etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
 {
   lhs.swap(rhs);
 }
@@ -2720,990 +2565,65 @@ namespace etl
 {
   //***************************************************************************
   template <size_t Active_Bits = 0U,
-            typename TElement = char,
-            bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
-    class bitset_ext;
-
-  //***************************************************************************
-  /// Specialisation for zero bits.
-  /// Just defines 'npos'.
-  //***************************************************************************
-  template <>
-  class bitset_ext<0U, char, true> : public bitset_constants<>
-  {
-  };
+            typename TElement = unsigned char>
+  class bitset_ext;
 
   //***************************************************************************
   /// Specialisation for zero bits.
   //***************************************************************************
   template <>
-  class bitset_ext<0U, char, false> : public bitset_constants<>
-  {
-  };
-
-  //***************************************************************************
-  /// Specialisation that uses a single element if the element type is the 
-  /// same size as the number of active bits.
-  //***************************************************************************
-  template <size_t   Active_Bits, typename TElement>
-  class bitset_ext<Active_Bits, TElement, true> : public bitset_constants<>
+  class bitset_ext<0U, unsigned char>
   {
   public:
 
-    // The element type is the unsigned variant of 'TElement'.
-    typedef typename etl::make_unsigned<TElement>::type element_type;
+    typedef unsigned char element_type;
 
     typedef element_type* pointer;
     typedef const element_type* const_pointer;
 
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT size_t       Number_Of_Elements = 1U;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Bits_Per_Element;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<typename etl::make_unsigned<element_type>::type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
+    static ETL_CONSTANT size_t       Bits_Per_Element   = 0U;
+    static ETL_CONSTANT size_t       Number_Of_Elements = 0U;
+    static ETL_CONSTANT size_t       Allocated_Bits     = 0U;
+    static ETL_CONSTANT element_type All_Set_Element    = 0U;
+    static ETL_CONSTANT element_type All_Clear_Element  = 0U;
     static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
-    static ETL_CONSTANT element_type Top_Mask           = All_Set_Element;
+    static ETL_CONSTANT element_type Top_Mask           = 0U;
 
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
-
-    typedef element_type buffer_type;
-
-    //*************************************************************************
-    /// The reference type returned.
-    //*************************************************************************
-    class bit_reference
-    {
-    public:
-
-      friend class bitset_ext;
-
-      //*******************************
-      /// Copy constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
-        : p_bitset(other.p_bitset)
-        , position(other.position)
-      {
-      }
-
-      //*******************************
-      /// Conversion operator.
-      //*******************************
-      ETL_CONSTEXPR14 operator bool() const ETL_NOEXCEPT
-      {
-        return p_bitset->test(position);
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (bool b) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, b);
-        return *this;
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, bool(r));
-        return *this;
-      }
-
-      //*******************************
-      /// Flip the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& flip() ETL_NOEXCEPT
-      {
-        p_bitset->flip(position);
-        return *this;
-      }
-
-      //*******************************
-      /// Return the logical inverse of the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bool operator~() const ETL_NOEXCEPT
-      {
-        return !p_bitset->test(position);
-      }
-
-    private:
-
-      //*******************************
-      /// Default constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference() ETL_NOEXCEPT
-        : p_bitset(ETL_NULLPTR)
-        , position(0)
-      {
-      }
-
-      //*******************************
-      /// Constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(bitset_ext<Active_Bits, TElement, true>& r_bitset, size_t position_) ETL_NOEXCEPT
-        : p_bitset(&r_bitset)
-        , position(position_)
-      {
-      }
-
-      bitset_ext<Active_Bits, TElement, true>* p_bitset; ///< The bitset.
-      size_t position; ///< The position in the bitset.
-    };
-
-    //*************************************************************************
-    /// Default constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 explicit bitset_ext(element_type* pbuffer_)
-      : pbuffer(pbuffer_)
-    {
-      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      *pbuffer = All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Default constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 explicit bitset_ext(buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Construct copy.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other, element_type* pbuffer_)
-      : pbuffer(pbuffer_)
-    {
-      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      *pbuffer = *other.pbuffer;
-    }
-
-    //*************************************************************************
-    /// Construct copy.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = *other.pbuffer;
-    }
-
-    //*************************************************************************
-    /// Copy Constructor (Deleted).
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT ETL_DELETE;
-
-    //*************************************************************************
-    /// Construct from a value.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_)
-      : pbuffer(pbuffer_)
-    {
-      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      *pbuffer = element_type(value);
-    }
-
-    //*************************************************************************
-    /// Construct from a value.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = element_type(value);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_)
-      : pbuffer(pbuffer_)
-    {
-      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_)
-      : pbuffer(pbuffer_)
-    {
-      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_)
-      : pbuffer(pbuffer_)
-    {
-      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_)
-      : pbuffer(pbuffer_)
-    {
-      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Assignment operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      *pbuffer = *other.pbuffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set() ETL_NOEXCEPT
-    {
-      *pbuffer = All_Set_Element;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(size_t position, bool value = true)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      if (value == true)
-      {
-        *pbuffer |= mask;
-      }
-      else
-      {
-        *pbuffer &= ~mask;
-      }
-      
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const char* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const wchar_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const char16_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const char32_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const char* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STR('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a wide string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const wchar_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRL('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a u16 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const char16_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRu('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a u32 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const char32_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRU('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Get as an integral value.
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value() const ETL_NOEXCEPT
-    {
-      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Integral type too small");
-
-      T v = T(0);
-
-      const bool OK = (sizeof(T) * CHAR_BIT) >= Bits_Per_Element;
-
-      if (OK)
-      {
-        v = T(typename etl::make_unsigned<T>::type(*pbuffer));
-      }
-
-      return v;
-    }
-
-    //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
-    {
-      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
-
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      const unsigned_t Mask = etl::make_lsb_mask<unsigned_t>(length);
-      const unsigned_t Shift = position % Bits_Per_Element;
-
-      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
-
-      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
-      {
-        value = etl::sign_extend<T>(value, length);
-      }
-
-      return static_cast<T>(value);
-    }
-
-    //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
-    //*************************************************************************
-    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
-    ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      extract() const ETL_NOEXCEPT
-    {
-      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
-
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      const unsigned_t Mask = etl::make_lsb_mask<unsigned_t, Length>();
-      const unsigned_t Shift = Position % Bits_Per_Element;
-
-      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
-
-      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
-      {
-        value = etl::sign_extend<T, Length>(value);
-      }
-
-      return static_cast<T>(value);
-    }
-
-    //*************************************************************************
-    /// Get as an unsigned long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long>();
-    }
-
-    //*************************************************************************
-    /// Get as an unsigned long long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long long>();
-    }
-
-    //*************************************************************************
-    /// Reset all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& reset() ETL_NOEXCEPT
-    {
-      *pbuffer = All_Clear_Element;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Reset the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& reset(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      *pbuffer &= ~mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Tests a bit at a position.
-    /// Positions greater than the number of configured bits will return <b>false</b>.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool test(size_t position) const
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
-
-      const element_type mask = element_type(element_type(1) << position);
-      return (*pbuffer & mask) != 0U;
-    }
-
-    //*************************************************************************
-    /// The number of bits in the bitset.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
-    {
-      return Active_Bits;
-    }
-
-    //*************************************************************************
-    /// Count the number of bits set.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
-    {
-      return etl::count_bits(*pbuffer);
-    }
-
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
-    {
-      return *pbuffer == All_Set_Element;
-    }
-
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
-    {
-      return *pbuffer == (All_Set_Element & mask);
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
-    {
-      return *pbuffer == All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
-    {
-      return (*pbuffer & mask) == All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
-    {
-      return !none();
-    }
-
-    //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
-    {
-      return !none(mask);
-    }
-
-    //*************************************************************************
-    /// Flip all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& flip() ETL_NOEXCEPT
-    {
-      *pbuffer = ~*pbuffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Flip some of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& flip_bits(element_type mask = etl::integral_limits<element_type>::max) ETL_NOEXCEPT
-    {
-      *pbuffer ^= mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Flip the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& flip(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-
-      const element_type mask = element_type(element_type(1) << position);
-      *pbuffer ^= mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Read [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
-    {
-      if (position < Active_Bits)
-      {
-        const element_type mask = element_type(element_type(1) << position);
-        return (*pbuffer & mask) != 0U;
-      }
-
-      return false;
-    }
-
-    //*************************************************************************
-    /// Write [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bit_reference operator [] (size_t position) ETL_NOEXCEPT
-    {
-      return bit_reference(*this, position);
-    }
-
-    //*************************************************************************
-    /// Returns a string representing the bitset.
-    //*************************************************************************
-#if ETL_USING_CPP11
-    template <typename TString = etl::string<Active_Bits>>
-#else
-    template <typename TString>
-#endif
-    ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
-                                      typename TString::value_type one  = typename TString::value_type('1')) const
-    {
-      TString result;
-
-      result.resize(Active_Bits, '\0');
-
-      // Check that the string type can contain the digits.
-      ETL_ASSERT_OR_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result);
-
-      for (size_t i = Active_Bits; i > 0; --i)
-      {
-        result[Active_Bits - i] = test(i - 1) ? one : zero;
-      }
-
-      return result;
-    }
-
-    //*************************************************************************
-    /// Finds the first bit in the specified state.
-    ///\param state The state to search for.
-    ///\returns The position of the bit or npos if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
-    {
-      return find_next(state, 0U);
-    }
-
-    //*************************************************************************
-    /// Finds the next bit in the specified state.
-    ///\param state    The state to search for.
-    ///\param position The position to start from.
-    ///\returns The position of the bit or npos if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
-    {
-      if (position < Active_Bits)
-      {
-        // Where to start.
-        size_t bit = position;
-
-        element_type mask = 1U << position;
-
-        // Needs checking?
-        if ((state && (*pbuffer != All_Clear_Element)) || (!state && (*pbuffer != All_Set_Element)))
-        {
-          // For each bit in the element...
-          while (bit < Active_Bits)
-          {
-            // Equal to the required state?
-            if (((*pbuffer & mask) != 0) == state)
-            {
-              return bit;
-            }
-
-            // Move on to the next bit.
-            mask <<= 1;
-            ++bit;
-          }
-        }
-      }
-
-      return npos;
-    }
-
-    //*************************************************************************
-    /// operator &=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator &=(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      *pbuffer &= *other.pbuffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator |=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator |=(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      *pbuffer |= *other.pbuffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ^=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator ^=(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      *pbuffer ^= *other.pbuffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator <<=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator <<=(size_t shift) ETL_NOEXCEPT
-    {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        *pbuffer <<= shift;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator >>=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator >>=(size_t shift) ETL_NOEXCEPT
-    {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        *pbuffer >>= shift;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ==
-    //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext<Active_Bits, TElement, true>& lhs, const bitset_ext<Active_Bits, TElement, true>& rhs) ETL_NOEXCEPT
-    {
-      return (*lhs.pbuffer == *rhs.pbuffer);
-    }
-
-    //*************************************************************************
-    /// swap
-    //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      element_type temp = *pbuffer;
-      *pbuffer = *other.pbuffer;
-      *other.pbuffer = temp;
-    }
-
-    //*************************************************************************
-    /// span
-    /// Returns a span of the underlying buffer.
-    //*************************************************************************
-    ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT
-    {
-      return span_type(pbuffer, 1);
-    }
-
-    //*************************************************************************
-    /// span
-    /// Returns a const span of the underlying buffer.
-    //*************************************************************************
-    ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT
-    {
-      return const_span_type(pbuffer, 1);
-    }
-
-  private:
-
-    element_type* pbuffer;
+    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
   };
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Bits_Per_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Number_Of_Elements;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Allocated_Bits;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::All_Set_Element;
-    
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::All_Clear_Element;
-    
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Top_Mask_Shift;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::Top_Mask;
-
   //*************************************************************************
   /// The specialisation that uses an array of the default element type.
   //*************************************************************************
   template <size_t Active_Bits, typename TElement>
-  class bitset_ext<Active_Bits, TElement, false> : public bitset_constants<>
+  class bitset_ext// : public etl::private_bitset::bitset_common<Active_Bits, TEelement>
   {
-  private:
-
-    //*************************************************************************
-    // If the 'TElement' is the default 'void', then use 'char', otherwise uses
-    // the unsigned variant of 'TElement'.
-    //*************************************************************************
-    struct select_element_type
-    {
-      typedef typename etl::make_unsigned<typename etl::conditional<etl::is_same<void, TElement>::value, char, TElement>::type>::type type;
-    };
-
   public:
 
-    typedef typename select_element_type::type element_type;
-    typedef element_type* pointer;
+    ETL_STATIC_ASSERT(etl::is_unsigned<TElement>::value, "The element type must be unsigned");
+
+    typedef TElement            element_type;
+    typedef element_type*       pointer;
     typedef const element_type* const_pointer;
 
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::bitset_impl<element_type>::Bits_Per_Element;
+    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
+
+    //static ETL_CONSTANT bool Element_Layout = implementation::Element_Layout;
+
+    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
+    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
+    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
     static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
     static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
     static ETL_CONSTANT size_t       Top_Mask_Shift     = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-    static ETL_CONSTANT element_type All_Set_Element    = etl::bitset_impl<element_type>::All_Set_Element;
-    static ETL_CONSTANT element_type All_Clear_Element  = etl::bitset_impl<element_type>::All_Clear_Element;
     static ETL_CONSTANT element_type Top_Mask           = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
 
     static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
 
+    typedef etl::array<TElement, Number_Of_Elements>          buffer_type;
     typedef etl::span<element_type, Number_Of_Elements>       span_type;
     typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
 
-    typedef etl::array<element_type, Number_Of_Elements> buffer_type;
-
     //*************************************************************************
     /// The reference type returned.
     //*************************************************************************
@@ -3785,7 +2705,7 @@ namespace etl
       {
       }
 
-      bitset_ext<Active_Bits, TElement, false>* p_bitset; ///< The bitset.
+      bitset_ext<Active_Bits, TElement>* p_bitset; ///< The bitset.
       size_t position; ///< The position in the bitset.
     };
 
@@ -3812,7 +2732,7 @@ namespace etl
     //*************************************************************************
     /// Construct copy.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other, element_type* pbuffer_)
+    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement>& other, element_type* pbuffer_)
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
@@ -3822,7 +2742,7 @@ namespace etl
     //*************************************************************************
     /// Construct copy.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other, buffer_type& buffer) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement>& other, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
       etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
@@ -3831,7 +2751,7 @@ namespace etl
     //*************************************************************************
     /// Copy Constructor (Deleted).
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT ETL_DELETE;
+    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT ETL_DELETE;
 
     //*************************************************************************
     /// Construct from a value.
@@ -3840,8 +2760,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      ibitset.initialise(pbuffer, Number_Of_Elements, value);
-      clear_unused_bits_in_msb();
+      implementation::initialise(pbuffer, Number_Of_Elements, value);
     }
 
     //*************************************************************************
@@ -3850,8 +2769,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset_ext(unsigned long long value, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.initialise(pbuffer, Number_Of_Elements, value);
-      clear_unused_bits_in_msb();
+      implementation::initialise(pbuffer, Number_Of_Elements, value);
     }
 
     //*************************************************************************
@@ -3861,8 +2779,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -3871,8 +2788,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -3882,8 +2798,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -3892,8 +2807,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -3903,8 +2817,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -3913,8 +2826,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -3924,8 +2836,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -3934,16 +2845,15 @@ namespace etl
     ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Assignment operator.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
+      implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements);
 
       return *this;
     }
@@ -3951,10 +2861,9 @@ namespace etl
     //*************************************************************************
     /// Set all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set() ETL_NOEXCEPT
     {
-      etl::fill_n(pbuffer, Number_Of_Elements, All_Set_Element);
-      clear_unused_bits_in_msb();
+      implementation::set(pbuffer, Number_Of_Elements, All_Set_Element);
 
       return *this;
     }
@@ -3962,12 +2871,11 @@ namespace etl
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(size_t position, bool value = true)
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(size_t position, bool value = true)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
       
-      ibitset.set(pbuffer, Number_Of_Elements, position, value);
-      clear_unused_bits_in_msb();
+      implementation::set(pbuffer, Number_Of_Elements, position, value);
 
       return *this;
     }
@@ -3975,9 +2883,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const char* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char* text) ETL_NOEXCEPT
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3985,9 +2893,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const wchar_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const wchar_t* text) ETL_NOEXCEPT
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3995,9 +2903,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char16_t* text) ETL_NOEXCEPT
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -4005,9 +2913,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char32_t* text) ETL_NOEXCEPT
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -4015,9 +2923,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const char* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const char* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -4025,9 +2933,9 @@ namespace etl
     //*************************************************************************
     /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const wchar_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const wchar_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -4035,9 +2943,9 @@ namespace etl
     //*************************************************************************
     /// Set from a u16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const char16_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -4045,9 +2953,9 @@ namespace etl
     //*************************************************************************
     /// Set from a u32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const char32_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -4057,13 +2965,12 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value() const ETL_NOEXCEPT
+    T value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
+      ETL_STATIC_ASSERT(etl::integral_limits<T>::bits >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
 
-      return ibitset.template value<T>(pbuffer, Number_Of_Elements);
+      return implementation::template value<T>(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -4071,21 +2978,14 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+      T extract(size_t position, size_t length = etl::integral_limits<T>::bits)
     {
-      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0);
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
 
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
+      ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
 
-      unsigned_t value = ibitset.template extract_from_buffer<T>(pbuffer, position, length);
-
-      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
-      {
-        value = etl::sign_extend<T>(value, length);
-      }
-
-      return static_cast<T>(value);
+      return implementation::extract<T>(pbuffer, position, length);
     }
 
     //*************************************************************************
@@ -4093,21 +2993,13 @@ namespace etl
     //*************************************************************************
     template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
     ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      extract() const ETL_NOEXCEPT
+      T extract() const
     {
-      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset");
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value,              "Only integral types are supported");
+      ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
 
-      typedef typename etl::make_unsigned<T>::type unsigned_t;
-
-      unsigned_t value = ibitset.template extract_from_buffer<T, Position, Length>(pbuffer);
-
-      if ETL_IF_CONSTEXPR((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
-      {
-        value = etl::sign_extend<T, Length>(value);
-      }
-
-      return static_cast<T>(value);
+      return implementation::extract<T>(pbuffer, Position, Length);
     }
 
     //*************************************************************************
@@ -4115,7 +3007,9 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
     {
-      return value<unsigned long>();
+      ETL_STATIC_ASSERT(etl::integral_limits<unsigned long>::bits >= Active_Bits, "Active_Bits > unsigned long");
+
+      return implementation::template value<unsigned long>(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -4123,14 +3017,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
     {
-      return value<unsigned long long>();
+      ETL_STATIC_ASSERT(etl::integral_limits<unsigned long long>::bits >= Active_Bits, "Active_Bits > unsigned long long");
+
+      return implementation::template value<unsigned long long>(pbuffer, Number_Of_Elements);
     }
+
     //*************************************************************************
     /// Reset all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& reset() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& reset() ETL_NOEXCEPT
     {
-      etl::fill_n(pbuffer, Number_Of_Elements, All_Clear_Element);
+      implementation::reset(pbuffer, Number_Of_Elements);
 
       return *this;
     }
@@ -4138,11 +3035,11 @@ namespace etl
     //*************************************************************************
     /// Reset the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& reset(size_t position)
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& reset(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      ibitset.reset(pbuffer, Number_Of_Elements, position);
+      implementation::reset(pbuffer, Number_Of_Elements, position);
 
       return *this;
     }
@@ -4155,7 +3052,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
       
-      return ibitset.test(pbuffer, Number_Of_Elements, position);
+      return implementation::test(pbuffer, Number_Of_Elements, position);
     }
 
     //*************************************************************************
@@ -4171,7 +3068,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
     {
-      return ibitset.count(pbuffer, Number_Of_Elements);
+      return implementation::count(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -4179,7 +3076,15 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
     {
-      return ibitset.all(pbuffer, Number_Of_Elements, Top_Mask);
+      return implementation::all(pbuffer, Number_Of_Elements, Top_Mask);
+    }
+
+    //*************************************************************************
+    // Are all the mask bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
+    {
+      return implementation::all(pbuffer, Number_Of_Elements, Top_Mask, mask);
     }
 
     //*************************************************************************
@@ -4187,7 +3092,15 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
     {
-      return ibitset.none(pbuffer, Number_Of_Elements);
+      return implementation::none(pbuffer, Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// Are none of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
+    {
+      return implementation::none(pbuffer, Number_Of_Elements, mask);
     }
 
     //*************************************************************************
@@ -4195,16 +3108,23 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
     {
-      return !none();
+      return implementation::any(pbuffer, Number_Of_Elements, Top_Mask);
+    }
+
+    //*************************************************************************
+    /// Are any of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
+    {
+      return implementation::any(pbuffer, Number_Of_Elements, Top_Mask, mask);
     }
 
     //*************************************************************************
     /// Flip all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& flip() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& flip() ETL_NOEXCEPT
     {
-      ibitset.flip(pbuffer, Number_Of_Elements);
-      clear_unused_bits_in_msb();
+      implementation::flip(pbuffer, Number_Of_Elements);
 
       return *this;
     }
@@ -4212,11 +3132,11 @@ namespace etl
     //*************************************************************************
     /// Flip the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& flip(size_t position)
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& flip(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
       
-      ibitset.flip(pbuffer, Number_Of_Elements, position);
+      implementation::flip(pbuffer, Number_Of_Elements, position);
 
       return *this;
     }
@@ -4226,7 +3146,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
     {
-      return ibitset.test(pbuffer, Number_Of_Elements, position);
+      return implementation::test(pbuffer, Number_Of_Elements, position);
     }
 
     //*************************************************************************
@@ -4248,7 +3168,7 @@ namespace etl
     ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
       typename TString::value_type one = typename TString::value_type('1')) const
     {
-      return ibitset.template to_string<TString>(pbuffer, Number_Of_Elements, Active_Bits, zero, one);
+      return implementation::template to_string<TString>(pbuffer, Number_Of_Elements, Active_Bits, zero, one);
     }
 
     //*************************************************************************
@@ -4258,7 +3178,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
     {
-      return ibitset.find_next(pbuffer, Number_Of_Elements, Active_Bits, state, 0);
+      return implementation::find_next(pbuffer, Number_Of_Elements, Active_Bits, state, 0);
     }
 
     //*************************************************************************
@@ -4269,15 +3189,15 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
     {
-      return ibitset.find_next(pbuffer, Number_Of_Elements, Active_Bits, state, position);
+      return implementation::find_next(pbuffer, Number_Of_Elements, Active_Bits, state, position);
     }
 
     //*************************************************************************
     /// operator &=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator &=(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator &=(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.and_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
+      implementation::operator_and(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -4285,9 +3205,9 @@ namespace etl
     //*************************************************************************
     /// operator |=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator |=(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator |=(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.or_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
+      implementation::operator_or(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -4295,9 +3215,9 @@ namespace etl
     //*************************************************************************
     /// operator ^=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator ^=(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator ^=(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.xor_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
+      implementation::xoperator_or(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -4305,17 +3225,9 @@ namespace etl
     //*************************************************************************
     /// operator <<=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator <<=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator <<=(size_t shift) ETL_NOEXCEPT
     {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        ibitset.shift_left_equals(pbuffer, Number_Of_Elements, shift);
-        clear_unused_bits_in_msb();
-      }
+      implementation::operator_shift_left(pbuffer, Number_Of_Elements, Active_Bits, shift);
 
       return *this;
     }
@@ -4323,16 +3235,9 @@ namespace etl
     //*************************************************************************
     /// operator >>=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator >>=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator >>=(size_t shift) ETL_NOEXCEPT
     {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        ibitset.shift_right_equals(pbuffer, Number_Of_Elements, shift);
-      }
+      implementation::operator_shift_right(pbuffer, Number_Of_Elements, Active_Bits, shift);
 
       return *this;
     }
@@ -4340,19 +3245,17 @@ namespace etl
     //*************************************************************************
     /// operator ==
     //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext<Active_Bits, TElement, false>& lhs, const bitset_ext<Active_Bits, TElement, false>& rhs) ETL_NOEXCEPT
+    friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext<Active_Bits, TElement>& lhs, const bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
     {
-      return etl::equal(lhs.pbuffer,
-        lhs.pbuffer + lhs.Number_Of_Elements,
-        rhs.pbuffer);
+      return etl::equal(lhs.pbuffer, lhs.pbuffer + lhs.Number_Of_Elements, rhs.pbuffer);
     }
 
     //*************************************************************************
     /// swap
     //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.swap(pbuffer, other.pbuffer, Number_Of_Elements);
+      implementation::swap(pbuffer, other.pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -4378,42 +3281,24 @@ namespace etl
     //*************************************************************************
     /// Correct the unused top bits after bit manipulation.
     //*************************************************************************
-    ETL_CONSTEXPR14 void clear_unused_bits_in_msb() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 static void clear_unused_bits_in_msb() ETL_NOEXCEPT
     {
       pbuffer[Number_Of_Elements - 1U] &= Top_Mask;
     }
 
-    etl::bitset_impl<element_type> ibitset;
+    // The implementation of the bitset functionality.
+    typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_layout::Single : etl::bitset_layout::Multi> implementation;
+
+    // Pointer to the storage for the bitset.
     element_type* pbuffer;
   };
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Bits_Per_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Number_Of_Elements;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Allocated_Bits;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::All_Set_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::All_Clear_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Top_Mask_Shift;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::Top_Mask;
-
   //***************************************************************************
   /// operator !=
   ///\ingroup bitset
   //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bool operator != (const bitset_ext<Active_Bits, TElement, IsSingleElement>& lhs, const bitset_ext<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+  template<size_t Active_Bits, typename TElement>
+  ETL_CONSTEXPR14 bool operator != (const bitset_ext<Active_Bits, TElement>& lhs, const bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
   {
     return !(lhs == rhs);
   }
@@ -4422,13 +3307,12 @@ namespace etl
 //*************************************************************************
 /// swap
 //*************************************************************************
-template <size_t Active_Bits, typename TElement, bool IsSingleElement>
-ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement, IsSingleElement>& lhs, etl::bitset_ext<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+template <size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement>& lhs, etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
 {
   lhs.swap(rhs);
 }
 
-
 #include "minmax_pop.h"
 
 #endif
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index 05ed79a9..291c6836 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -123,7 +123,7 @@ namespace
     TEST(test_default_constructor)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare;
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data;
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -137,10 +137,10 @@ namespace
     //*************************************************************************
     TEST(test_default_constructor_single_element)
     {
-      etl::bitset<8,  int8_t>  data8;
-      etl::bitset<16, int16_t> data16;
-      etl::bitset<32, int32_t> data32;
-      etl::bitset<64, int64_t> data64;
+      etl::bitset<8,  uint8_t>  data8;
+      etl::bitset<16, uint16_t> data16;
+      etl::bitset<32, uint32_t> data32;
+      etl::bitset<64, uint64_t> data64;
 
       CHECK_EQUAL(1U, data8.Number_Of_Elements);
       CHECK_EQUAL(1U, data16.Number_Of_Elements);
@@ -152,7 +152,7 @@ namespace
     TEST(test_construct_from_value)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x123456731234567ULL);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -168,10 +168,10 @@ namespace
     TEST(test_copy_construct)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data_copy(data);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data_copy(data);
 
-      CHECK_EQUAL(compare.size(), data_copy.size());
+      CHECK_EQUAL(compare.size(),  data_copy.size());
       CHECK_EQUAL(compare.count(), data_copy.count());
 
       for (size_t i = 0UL; i < data_copy.size(); ++i)
@@ -184,7 +184,7 @@ namespace
     TEST(test_construct_from_excess_value)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare(0x8765432187654321ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x8765432187654321ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x8765432187654321ULL);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -199,7 +199,7 @@ namespace
     TEST(test_construct_from_char_string)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001");
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -214,9 +214,9 @@ namespace
     TEST(test_construct_from_wchar_t_string)
     {
       std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data(L"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64, uint64_t> data(L"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -229,9 +229,9 @@ namespace
     TEST(test_construct_from_char16_t_string)
     {
       std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data(u"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64, uint64_t> data(u"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -244,9 +244,9 @@ namespace
     TEST(test_construct_from_char32_t_string)
     {
       std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data(U"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64, uint64_t> data(U"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -260,7 +260,7 @@ namespace
     {
       const char* s = nullptr;
 
-      etl::bitset<60, int64_t> data(s);
+      etl::bitset<60, uint64_t> data(s);
 
       CHECK_EQUAL(60, data.size());
       CHECK_EQUAL(0, data.count());
@@ -271,10 +271,10 @@ namespace
     {
       const wchar_t* s = nullptr;
 
-      etl::bitset<60, int64_t> data(s);
+      etl::bitset<60, uint64_t> data(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
@@ -282,10 +282,10 @@ namespace
     {
       const char16_t* s = nullptr;
 
-      etl::bitset<60, int64_t> data(s);
+      etl::bitset<60, uint64_t> data(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
@@ -293,17 +293,17 @@ namespace
     {
       const char32_t* s = nullptr;
 
-      etl::bitset<60, int64_t> data(s);
+      etl::bitset<60, uint64_t> data(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
     TEST(test_construct_from_excess_string)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001");
-      etl::bitset<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001111100001");
+      etl::bitset<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001111100001");
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -320,9 +320,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_set_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_helper()
     {
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
       data.set();
 
       return data;
@@ -331,7 +331,7 @@ namespace
     TEST(test_set)
     {
       std::bitset<64> compare;
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_set_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_helper());
 
       compare.set();
 
@@ -357,7 +357,7 @@ namespace
     TEST(test_set_with_char_string)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.set("110001001000110100010101100111001100010010001101000101011001");
 
@@ -377,15 +377,15 @@ namespace
     TEST(test_set_with_wchar_t_string)
     {
       std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.set(L"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -397,15 +397,15 @@ namespace
     TEST(test_set_with_char16_t_string)
     {
       std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.set(u"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -417,15 +417,15 @@ namespace
     TEST(test_set_with_char32_t_string)
     {
       std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.set(U"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -438,11 +438,11 @@ namespace
     {
       const char* s = nullptr;
 
-      etl::bitset<60, int64_t> data;
+      etl::bitset<60, uint64_t> data;
       data.set(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
@@ -450,11 +450,11 @@ namespace
     {
       const wchar_t* s = nullptr;
 
-      etl::bitset<60, int64_t> data;
+      etl::bitset<60, uint64_t> data;
       data.set(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
@@ -462,11 +462,11 @@ namespace
     {
       const char16_t* s = nullptr;
 
-      etl::bitset<60, int64_t> data;
+      etl::bitset<60, uint64_t> data;
       data.set(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
@@ -474,26 +474,26 @@ namespace
     {
       const char32_t* s = nullptr;
 
-      etl::bitset<60, int64_t> data;
+      etl::bitset<60, uint64_t> data;
       data.set(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
     TEST(test_from_string_with_char)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.from_string("110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -505,15 +505,15 @@ namespace
     TEST(test_from_string_with_wchar_t)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.from_string(L"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -525,15 +525,15 @@ namespace
     TEST(test_from_char16_t_6string)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.from_string(u"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -545,15 +545,15 @@ namespace
     TEST(test_from_string_with_char32_t)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.from_string(U"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -566,11 +566,11 @@ namespace
     {
       const char* s = nullptr;
 
-      etl::bitset<60, int64_t> data;
+      etl::bitset<60, uint64_t> data;
       data.from_string(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
@@ -578,11 +578,11 @@ namespace
     {
       const wchar_t* s = nullptr;
 
-      etl::bitset<60, int64_t> data;
+      etl::bitset<60, uint64_t> data;
       data.from_string(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
@@ -590,11 +590,11 @@ namespace
     {
       const char16_t* s = nullptr;
 
-      etl::bitset<60, int64_t> data;
+      etl::bitset<60, uint64_t> data;
       data.from_string(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
@@ -602,11 +602,11 @@ namespace
     {
       const char32_t* s = nullptr;
 
-      etl::bitset<60, int64_t> data;
+      etl::bitset<60, uint64_t> data;
       data.from_string(s);
 
       CHECK_EQUAL(60, data.size());
-      CHECK_EQUAL(0, data.count());
+      CHECK_EQUAL(0,  data.count());
     }
 
     //*************************************************************************
@@ -721,7 +721,7 @@ namespace
     TEST(test_value_u64_min)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::min);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
     }
@@ -730,7 +730,7 @@ namespace
     TEST(test_value_u64_max)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::max);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
     }
@@ -739,7 +739,7 @@ namespace
     TEST(test_value_s64_min)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::min);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
     }
@@ -748,7 +748,7 @@ namespace
     TEST(test_value_s64_max)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::max);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
     }
@@ -757,7 +757,7 @@ namespace
     TEST(test_position_set)
     {
       std::bitset<64> compare;
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -786,9 +786,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_reset_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_reset_helper()
     {
-      etl::bitset<64, int64_t> data(0xFFFFFFFFFFFFFFFULL);
+      etl::bitset<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL);
       data.reset();
 
       return data;
@@ -797,7 +797,7 @@ namespace
     TEST(test_reset)
     {
       std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_reset_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_reset_helper());
 
       compare.reset();
       
@@ -814,9 +814,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_position_reset_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_position_reset_helper()
     {
-      etl::bitset<64, int64_t> data(0xFFFFFFFFFFFFFFFULL);
+      etl::bitset<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL);
       data.reset(1);
       data.reset(3);
       data.reset(7);
@@ -828,7 +828,7 @@ namespace
     TEST(test_position_reset)
     {
       std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_position_reset_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_position_reset_helper());
 
       compare.reset(1);
       compare.reset(3);
@@ -875,7 +875,7 @@ namespace
     TEST(test_index_operator_read)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare(0x3123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x3123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x3123456731234567ULL);
 
       ETL_CONSTEXPR14 bool bc0 = compare[1U];
       ETL_CONSTEXPR14 bool bd0 = data[1U];
@@ -895,9 +895,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_index_operator_write_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_index_operator_write_helper()
     {
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data[1U]  = true;
       data[3U]  = true;
@@ -909,7 +909,7 @@ namespace
 
     TEST(test_index_operator_write)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_index_operator_write_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_index_operator_write_helper());
 
       CHECK(data[1U]);
       CHECK(data[3U]);
@@ -920,10 +920,10 @@ namespace
     //*************************************************************************
     TEST(test_any)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.any();
       ETL_CONSTEXPR14 bool bd2 = data2.any();
@@ -939,10 +939,10 @@ namespace
     //*************************************************************************
     TEST(test_any_with_mask)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0xF000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0xF000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -960,10 +960,10 @@ namespace
     //*************************************************************************
     TEST(test_none)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.none();
       ETL_CONSTEXPR14 bool bd2 = data2.none();
@@ -979,10 +979,10 @@ namespace
     //*************************************************************************
     TEST(test_none_with_mask)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0xF000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0xF000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -1000,10 +1000,10 @@ namespace
     //*************************************************************************
     TEST(test_all)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.all();
       ETL_CONSTEXPR14 bool bd2 = data2.all();
@@ -1019,10 +1019,10 @@ namespace
     //*************************************************************************
     TEST(test_all_with_mask)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0x0FFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -1038,9 +1038,129 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_helper()
+    TEST(test_any_with_reduced_active_bits)
     {
-      etl::bitset<64, int64_t> data;
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.any();
+      ETL_CONSTEXPR14 bool bd2 = data2.any();
+      ETL_CONSTEXPR14 bool bd3 = data3.any();
+      ETL_CONSTEXPR14 bool bd4 = data4.any();
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_any_with_mask_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0xF000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF);
+
+      ETL_CONSTEXPR14 bool bd1 = data1.any(mask);
+      ETL_CONSTEXPR14 bool bd2 = data2.any(mask);
+      ETL_CONSTEXPR14 bool bd3 = data3.any(mask);
+      ETL_CONSTEXPR14 bool bd4 = data4.any(mask);
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.none();
+      ETL_CONSTEXPR14 bool bd2 = data2.none();
+      ETL_CONSTEXPR14 bool bd3 = data3.none();
+      ETL_CONSTEXPR14 bool bd4 = data4.none();
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_mask_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0xF000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF);
+
+      ETL_CONSTEXPR14 bool bd1 = data1.none(mask);
+      ETL_CONSTEXPR14 bool bd2 = data2.none(mask);
+      ETL_CONSTEXPR14 bool bd3 = data3.none(mask);
+      ETL_CONSTEXPR14 bool bd4 = data4.none(mask);
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.all();
+      ETL_CONSTEXPR14 bool bd2 = data2.all();
+      ETL_CONSTEXPR14 bool bd3 = data3.all();
+      ETL_CONSTEXPR14 bool bd4 = data4.all();
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_mask_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 ull mask = ull(0x00FFFFFFFFFFFFFF);
+
+      ETL_CONSTEXPR14 bool bd1 = data1.all(mask);
+      ETL_CONSTEXPR14 bool bd2 = data2.all(mask);
+      ETL_CONSTEXPR14 bool bd3 = data3.all(mask);
+      ETL_CONSTEXPR14 bool bd4 = data4.all(mask);
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_helper()
+    {
+      etl::bitset<64, uint64_t> data;
       data.flip();
 
       return data;
@@ -1049,7 +1169,7 @@ namespace
     TEST(test_flip)
     {
       std::bitset<64> compare;
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_helper());
 
       compare.flip();
 
@@ -1060,9 +1180,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_position_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_position_helper()
     {
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
       data.flip(1);
       data.flip(3);
       data.flip(7);
@@ -1074,7 +1194,7 @@ namespace
     TEST(test_flip_position)
     {
       std::bitset<64> compare;
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_position_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_position_helper());
 
       compare.flip(1);
       compare.flip(3);
@@ -1088,9 +1208,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_reference_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_reference_helper()
     {
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
       data[1].flip();
       data[3].flip();
       data[7].flip();
@@ -1102,7 +1222,7 @@ namespace
     TEST(test_flip_reference)
     {
       std::bitset<64> compare;
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_reference_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_reference_helper());
 
       compare[1].flip();
       compare[3].flip();
@@ -1119,7 +1239,7 @@ namespace
     TEST(test_invert_reference)
     {
       std::bitset<64> compare;
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       bool bc = ~compare[3];
       bool bd = ~data[3];
@@ -1127,7 +1247,7 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_assignment_operator_helper(etl::bitset<64, int64_t> to, const etl::bitset<64, int64_t>& from)
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_assignment_operator_helper(etl::bitset<64, uint64_t> to, const etl::bitset<64, uint64_t>& from)
     {
       to = from;
 
@@ -1137,8 +1257,8 @@ namespace
     TEST(test_assignment_operator)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0xFFFFFFFFFFFFFFFULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(test_assignment_operator_helper(etl::bitset<64, int64_t>(), data1));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0xFFFFFFFFFFFFFFFULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(test_assignment_operator_helper(etl::bitset<64, uint64_t>(), data1));
 
       for (size_t i = 0UL; i < data2.size(); ++i)
       {
@@ -1149,9 +1269,9 @@ namespace
     //*************************************************************************
     TEST(test_equality_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3;
 
       ETL_CONSTEXPR14 bool equal     =  (data1 == data2);
       ETL_CONSTEXPR14 bool not_equal = !(data1 == data3);
@@ -1163,9 +1283,9 @@ namespace
     //*************************************************************************
     TEST(test_inequality_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3;
 
       ETL_CONSTEXPR14 bool equal = !(data1 != data2);
       ETL_CONSTEXPR14 bool not_equal = (data1 != data3);
@@ -1177,38 +1297,38 @@ namespace
     //*************************************************************************
     TEST(test_shift_left_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift1(0x2468ACF0ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift2(0x48D159E0ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift11(0x91A2B3C000ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift1(0x2468ACF0ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift2(0x48D159E0ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift11(0x91A2B3C000ULL);
 
-      CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 1U)) == shift1);
-      CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 2U)) == shift2);
-      CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 11U)) == shift11);
+      CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 1U)) == shift1);
+      CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 2U)) == shift2);
+      CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 11U)) == shift11);
     }
 
     //*************************************************************************
     TEST(test_shift_left_operator_overflow)
     {
-      ETL_CONSTEXPR14 etl::bitset<32, int32_t> data(generate_shift_left_bitset<32, int32_t>(0x7FFFFFFFULL, 1U));
-      ETL_CONSTEXPR14 etl::bitset<32, int32_t> shifted(0xFFFFFFFEUL);
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> data(generate_shift_left_bitset<32, uint32_t>(0x7FFFFFFFULL, 1U));
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> shifted(0xFFFFFFFEUL);
 
-      CHECK_EQUAL_HEX(shifted.value<int32_t>(), data.value<int32_t>());
+      CHECK_EQUAL_HEX(shifted.value<uint32_t>(), data.value<uint32_t>());
     }
 
     //*************************************************************************
     TEST(test_shift_left_copy_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift8(0x1234567800ULL);
-      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 8U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift8(0x1234567800ULL);
+      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 8U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift16(0x123456780000ULL);
-      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 16U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift16(0x123456780000ULL);
+      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 16U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift24(0x12345678000000ULL);
-      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 24U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift24(0x12345678000000ULL);
+      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 24U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift64(0x0000000000000000ULL);
-      CHECK_EQUAL_HEX(shift64.value<int64_t>(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 64U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift64(0x0000000000000000ULL);
+      CHECK_EQUAL_HEX(shift64.value<int64_t>(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
@@ -1286,189 +1406,189 @@ namespace
     //*************************************************************************
     TEST(test_shift_right_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift1(0x91A2B3CULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift2(0x48D159EULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift11(0x2468AULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift1(0x91A2B3CULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift2(0x48D159EULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift11(0x2468AULL);
 
-      CHECK_EQUAL_HEX(shift1.value<int64_t>(),  (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 1U).value<int64_t>()));
-      CHECK_EQUAL_HEX(shift2.value<int64_t>(),  (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 2U).value<int64_t>()));
-      CHECK_EQUAL_HEX(shift11.value<int64_t>(), (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 11U).value<int64_t>()));
+      CHECK_EQUAL_HEX(shift1.value<int64_t>(),  (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX(shift2.value<int64_t>(),  (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX(shift11.value<int64_t>(), (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 11U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_copy_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift8(0x123456ULL);
-      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 8U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift8(0x123456ULL);
+      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 8U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift16(0x1234ULL);
-      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 16U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift16(0x1234ULL);
+      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 16U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift24(0x12ULL);
-      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 24U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift24(0x12ULL);
+      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 24U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift60(0x00ULL);
-      CHECK_EQUAL_HEX(shift60.value<int64_t>(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 60U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift60(0x00ULL);
+      CHECK_EQUAL_HEX(shift60.value<int64_t>(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 60U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_operator_all_shifts_full_size)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
 
-      CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64, int64_t>(value, 0U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64, int64_t>(value, 1U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64, int64_t>(value, 2U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64, int64_t>(value, 3U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64, int64_t>(value, 4U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64, int64_t>(value, 5U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64, int64_t>(value, 6U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64, int64_t>(value, 7U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64, int64_t>(value, 8U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64, int64_t>(value, 9U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64, int64_t>(value, 10U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64, int64_t>(value, 11U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64, int64_t>(value, 12U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64, int64_t>(value, 13U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64, int64_t>(value, 14U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64, int64_t>(value, 15U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64, int64_t>(value, 16U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64, int64_t>(value, 17U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64, int64_t>(value, 18U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64, int64_t>(value, 19U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64, int64_t>(value, 20U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64, int64_t>(value, 21U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64, int64_t>(value, 22U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64, int64_t>(value, 23U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64, int64_t>(value, 24U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64, int64_t>(value, 25U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64, int64_t>(value, 26U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64, int64_t>(value, 27U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64, int64_t>(value, 28U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64, int64_t>(value, 29U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64, int64_t>(value, 30U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64, int64_t>(value, 31U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64, int64_t>(value, 32U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64, int64_t>(value, 33U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64, int64_t>(value, 34U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64, int64_t>(value, 35U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64, int64_t>(value, 36U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64, int64_t>(value, 37U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64, int64_t>(value, 38U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64, int64_t>(value, 39U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64, int64_t>(value, 40U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64, int64_t>(value, 41U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64, int64_t>(value, 42U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64, int64_t>(value, 43U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64, int64_t>(value, 44U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64, int64_t>(value, 45U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64, int64_t>(value, 46U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64, int64_t>(value, 47U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64, int64_t>(value, 48U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64, int64_t>(value, 49U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64, int64_t>(value, 50U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64, int64_t>(value, 51U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64, int64_t>(value, 52U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64, int64_t>(value, 53U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64, int64_t>(value, 54U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64, int64_t>(value, 55U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64, int64_t>(value, 56U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64, int64_t>(value, 57U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64, int64_t>(value, 58U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64, int64_t>(value, 59U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64, int64_t>(value, 60U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64, int64_t>(value, 61U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64, int64_t>(value, 62U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64, int64_t>(value, 63U).value<int64_t>()));
-      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, int64_t>(value, 64U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64, uint64_t>(value, 0U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64, uint64_t>(value, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64, uint64_t>(value, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64, uint64_t>(value, 3U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64, uint64_t>(value, 4U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64, uint64_t>(value, 5U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64, uint64_t>(value, 6U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64, uint64_t>(value, 7U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64, uint64_t>(value, 8U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64, uint64_t>(value, 9U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64, uint64_t>(value, 10U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64, uint64_t>(value, 11U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64, uint64_t>(value, 12U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64, uint64_t>(value, 13U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64, uint64_t>(value, 14U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64, uint64_t>(value, 15U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64, uint64_t>(value, 16U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64, uint64_t>(value, 17U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64, uint64_t>(value, 18U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64, uint64_t>(value, 19U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64, uint64_t>(value, 20U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64, uint64_t>(value, 21U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64, uint64_t>(value, 22U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64, uint64_t>(value, 23U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64, uint64_t>(value, 24U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64, uint64_t>(value, 25U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64, uint64_t>(value, 26U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64, uint64_t>(value, 27U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64, uint64_t>(value, 28U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64, uint64_t>(value, 29U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64, uint64_t>(value, 30U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64, uint64_t>(value, 31U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64, uint64_t>(value, 32U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64, uint64_t>(value, 33U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64, uint64_t>(value, 34U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64, uint64_t>(value, 35U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64, uint64_t>(value, 36U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64, uint64_t>(value, 37U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64, uint64_t>(value, 38U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64, uint64_t>(value, 39U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64, uint64_t>(value, 40U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64, uint64_t>(value, 41U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64, uint64_t>(value, 42U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64, uint64_t>(value, 43U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64, uint64_t>(value, 44U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64, uint64_t>(value, 45U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64, uint64_t>(value, 46U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64, uint64_t>(value, 47U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64, uint64_t>(value, 48U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64, uint64_t>(value, 49U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64, uint64_t>(value, 50U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64, uint64_t>(value, 51U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64, uint64_t>(value, 52U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64, uint64_t>(value, 53U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64, uint64_t>(value, 54U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64, uint64_t>(value, 55U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64, uint64_t>(value, 56U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64, uint64_t>(value, 57U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64, uint64_t>(value, 58U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64, uint64_t>(value, 59U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64, uint64_t>(value, 60U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64, uint64_t>(value, 61U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64, uint64_t>(value, 62U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64, uint64_t>(value, 63U).value<int64_t>()));
+      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, uint64_t>(value, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_operator_all_shifts_partial_size)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
-      int64_t mask  = 0x0FFFFFFFFFFFFFFFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
+      uint64_t mask  = 0x0FFFFFFFFFFFFFFFULL;
 
-      CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 0U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 1U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 2U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 3U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 4U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 5U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 6U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 7U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 8U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 9U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 10U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 11U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 12U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 13U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 14U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 15U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 16U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 17U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 18U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 19U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 20U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 21U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 22U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 23U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 24U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 25U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 26U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 27U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 28U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 29U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 30U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 31U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 32U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 33U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 34U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 35U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 36U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 37U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 38U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 39U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 40U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 41U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 42U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 43U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 44U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 45U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 46U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 47U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 48U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 49U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 50U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 51U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 52U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 53U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 54U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 55U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 56U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 57U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 58U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 59U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 60U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 61U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 62U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 63U).value<int64_t>()));
-      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, int64_t>(value, 64U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 0U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 3U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 4U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 5U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 6U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 7U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 8U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 9U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 10U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 11U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 12U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 13U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 14U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 15U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 16U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 17U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 18U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 19U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 20U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 21U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 22U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 23U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 24U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 25U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 26U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 27U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 28U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 29U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 30U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 31U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 32U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 33U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 34U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 35U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 36U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 37U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 38U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 39U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 40U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 41U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 42U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 43U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 44U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 45U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 46U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 47U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 48U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 49U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 50U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 51U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 52U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 53U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 54U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 55U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 56U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 57U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 58U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 59U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 60U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 61U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 62U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 63U).value<int64_t>()));
+      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, uint64_t>(value, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_and_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL & 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL & 0x23456789UL);
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 & data2;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 & data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_and_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2)
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_and_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2)
     {
       data1 &= data2;
 
@@ -1477,10 +1597,10 @@ namespace
     
     TEST(test_and_equals_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
       
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_and_equals_operator_helper(data1, data2));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_and_equals_operator_helper(data1, data2));
 
       CHECK((data1 & data2) == data3);
     }
@@ -1488,16 +1608,16 @@ namespace
     //*************************************************************************
     TEST(test_or_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL | 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL | 0x23456789UL);
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 | data2;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 | data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_or_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2)
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_or_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2)
     {
       data1 |= data2;
 
@@ -1506,10 +1626,10 @@ namespace
 
     TEST(test_or_equals_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_or_equals_operator_helper(data1, data2));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_or_equals_operator_helper(data1, data2));
 
       CHECK((data1 | data2) == data3);
     }
@@ -1517,16 +1637,16 @@ namespace
     //*************************************************************************
     TEST(test_xor_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL ^ 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL ^ 0x23456789UL);
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 ^ data2;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 ^ data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_xor_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2)
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_xor_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2)
     {
       data1 ^= data2;
 
@@ -1535,10 +1655,10 @@ namespace
 
     TEST(test_xor_equals_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_xor_equals_operator_helper(data1, data2));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_xor_equals_operator_helper(data1, data2));
 
       CHECK((data1 ^ data2) == data3);
     }
@@ -1546,102 +1666,102 @@ namespace
     //*************************************************************************
     TEST(test_find_first)
     {
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs1(ull(0x00));
-      ETL_CONSTEXPR14 size_t bs1fff = bs1.find_first(false);
-      ETL_CONSTEXPR14 size_t bs1fft = bs1.find_first(true);
-      CHECK_EQUAL(0U, bs1fff);
-      CHECK_EQUAL(etl::bitset<>::npos, bs1fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs1(ull(0x00));
+      ETL_CONSTEXPR14 size_t bs1find_first_false = bs1.find_first(false);
+      ETL_CONSTEXPR14 size_t bs1find_first_true  = bs1.find_first(true);
+      CHECK_EQUAL(0U, bs1find_first_false);
+      CHECK_EQUAL(etl::bitset<>::npos, bs1find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs2(ull(0xFF));
-      ETL_CONSTEXPR14 size_t bs2fff = bs2.find_first(false);
-      ETL_CONSTEXPR14 size_t bs2fft = bs2.find_first(true);
-      CHECK_EQUAL(etl::bitset<>::npos, bs2fff);
-      CHECK_EQUAL(0U, bs2fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs2(ull(0xFF));
+      ETL_CONSTEXPR14 size_t bs2find_first_false = bs2.find_first(false);
+      ETL_CONSTEXPR14 size_t bs2find_first_true  = bs2.find_first(true);
+      CHECK_EQUAL(etl::bitset<>::npos, bs2find_first_false);
+      CHECK_EQUAL(0U, bs2find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs3(ull(0x01));
-      ETL_CONSTEXPR14 size_t bs3fff = bs3.find_first(false);
-      ETL_CONSTEXPR14 size_t bs3fft = bs3.find_first(true);
-      CHECK_EQUAL(1U, bs3fff);
-      CHECK_EQUAL(0U, bs3fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs3(ull(0x01));
+      ETL_CONSTEXPR14 size_t bs3find_first_false = bs3.find_first(false);
+      ETL_CONSTEXPR14 size_t bs3find_first_true  = bs3.find_first(true);
+      CHECK_EQUAL(1U, bs3find_first_false);
+      CHECK_EQUAL(0U, bs3find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs4(ull(0x20));
-      ETL_CONSTEXPR14 size_t bs4fff = bs4.find_first(false);
-      ETL_CONSTEXPR14 size_t bs4fft = bs4.find_first(true);
-      CHECK_EQUAL(0U, bs4fff);
-      CHECK_EQUAL(5U, bs4fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs4(ull(0x20));
+      ETL_CONSTEXPR14 size_t bs4find_first_false = bs4.find_first(false);
+      ETL_CONSTEXPR14 size_t bs4find_first_true  = bs4.find_first(true);
+      CHECK_EQUAL(0U, bs4find_first_false);
+      CHECK_EQUAL(5U, bs4find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs5(ull(0x21));
-      ETL_CONSTEXPR14 size_t bs5fff = bs5.find_first(false);
-      ETL_CONSTEXPR14 size_t bs5fft = bs5.find_first(true);
-      CHECK_EQUAL(1U, bs5fff);
-      CHECK_EQUAL(0U, bs5fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs5(ull(0x21));
+      ETL_CONSTEXPR14 size_t bs5find_first_false = bs5.find_first(false);
+      ETL_CONSTEXPR14 size_t bs5find_first_true  = bs5.find_first(true);
+      CHECK_EQUAL(1U, bs5find_first_false);
+      CHECK_EQUAL(0U, bs5find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs6(ull(0x0E));
-      ETL_CONSTEXPR14 size_t bs6fff = bs6.find_first(false);
-      ETL_CONSTEXPR14 size_t bs6fft = bs6.find_first(true);
-      CHECK_EQUAL(0U, bs6fff);
-      CHECK_EQUAL(1U, bs6fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs6(ull(0x0E));
+      ETL_CONSTEXPR14 size_t bs6find_first_false = bs6.find_first(false);
+      ETL_CONSTEXPR14 size_t bs6find_first_true  = bs6.find_first(true);
+      CHECK_EQUAL(0U, bs6find_first_false);
+      CHECK_EQUAL(1U, bs6find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs7(ull(0x31));
-      ETL_CONSTEXPR14 size_t bs7fff = bs7.find_first(false);
-      ETL_CONSTEXPR14 size_t bs7fft = bs7.find_first(true);
-      CHECK_EQUAL(1U, bs7fff);
-      CHECK_EQUAL(0U, bs7fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs7(ull(0x31));
+      ETL_CONSTEXPR14 size_t bs7find_first_false = bs7.find_first(false);
+      ETL_CONSTEXPR14 size_t bs7find_first_true  = bs7.find_first(true);
+      CHECK_EQUAL(1U, bs7find_first_false);
+      CHECK_EQUAL(0U, bs7find_first_true);
     }
 
     //*************************************************************************
     TEST(test_find_next)
     {
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs1(ull(0x00));
-      ETL_CONSTEXPR14 size_t bs1fnf0 = bs1.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs1fnf1 = bs1.find_next(false, 1);
-      ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 2);
-      CHECK_EQUAL(0U, bs1fnf0);
-      CHECK_EQUAL(1U, bs1fnf1);
-      CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs1(ull(0x00));
+      ETL_CONSTEXPR14 size_t bs1find_next_false0 = bs1.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs1find_next_false1 = bs1.find_next(false, 1);
+      ETL_CONSTEXPR14 size_t bs1find_next_true2 = bs1.find_next(true, 2);
+      CHECK_EQUAL(0U, bs1find_next_false0);
+      CHECK_EQUAL(1U, bs1find_next_false1);
+      CHECK_EQUAL(etl::bitset<>::npos, bs1find_next_true2);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs2(ull(0xFF));
-      ETL_CONSTEXPR14 size_t bs2fnt0 = bs2.find_next(true, 0);
-      ETL_CONSTEXPR14 size_t bs2fnt1 = bs2.find_next(true, 1);
-      ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 2);
-      CHECK_EQUAL(0U, bs2fnt0);
-      CHECK_EQUAL(1U, bs2fnt1);
-      CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs2(ull(0xFF));
+      ETL_CONSTEXPR14 size_t bs2find_next_true0 = bs2.find_next(true, 0);
+      ETL_CONSTEXPR14 size_t bs2find_next_true1 = bs2.find_next(true, 1);
+      ETL_CONSTEXPR14 size_t bs2find_next_false2 = bs2.find_next(false, 2);
+      CHECK_EQUAL(0U, bs2find_next_true0);
+      CHECK_EQUAL(1U, bs2find_next_true1);
+      CHECK_EQUAL(etl::bitset<>::npos, bs2find_next_false2);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs3(ull(0x0E));
-      ETL_CONSTEXPR14 size_t bs3fnf0 = bs3.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs3fnt1 = bs3.find_next(true, 1);
-      ETL_CONSTEXPR14 size_t bs3fnf2 = bs3.find_next(false, 2);
-      CHECK_EQUAL(0U, bs3fnf0);
-      CHECK_EQUAL(1U, bs3fnt1);
-      CHECK_EQUAL(4U, bs3fnf2);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs3(ull(0x0E));
+      ETL_CONSTEXPR14 size_t bs3find_next_false0 = bs3.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs3find_next_true1 = bs3.find_next(true, 1);
+      ETL_CONSTEXPR14 size_t bs3find_next_false2 = bs3.find_next(false, 2);
+      CHECK_EQUAL(0U, bs3find_next_false0);
+      CHECK_EQUAL(1U, bs3find_next_true1);
+      CHECK_EQUAL(4U, bs3find_next_false2);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs4(ull(0x31));
-      ETL_CONSTEXPR14 size_t bs4fnt0 = bs4.find_next(true, 0);
-      ETL_CONSTEXPR14 size_t bs4fnf0 = bs4.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs4fnt1 = bs4.find_next(true, 1);
-      CHECK_EQUAL(0U, bs4fnt0);
-      CHECK_EQUAL(1U, bs4fnf0);
-      CHECK_EQUAL(4U, bs4fnt1);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs4(ull(0x31));
+      ETL_CONSTEXPR14 size_t bs4find_next_true0 = bs4.find_next(true, 0);
+      ETL_CONSTEXPR14 size_t bs4find_next_false0 = bs4.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs4find_next_true1 = bs4.find_next(true, 1);
+      CHECK_EQUAL(0U, bs4find_next_true0);
+      CHECK_EQUAL(1U, bs4find_next_false0);
+      CHECK_EQUAL(4U, bs4find_next_true1);
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 std::pair<etl::bitset<8, int8_t>, etl::bitset<8, int8_t>> test_swap_helper()
+    ETL_CONSTEXPR14 std::pair<etl::bitset<8, uint8_t>, etl::bitset<8, uint8_t>> test_swap_helper()
     {
-      etl::bitset<8, int8_t> data1(ull(0x2A));
-      etl::bitset<8, int8_t> data2(ull(0x15));
+      etl::bitset<8, uint8_t> data1(ull(0x2A));
+      etl::bitset<8, uint8_t> data2(ull(0x15));
 
       swap(data1, data2);
 
-      return std::pair<etl::bitset<8, int8_t>, etl::bitset<8, int8_t>>(data1, data2);
+      return std::pair<etl::bitset<8, uint8_t>, etl::bitset<8, uint8_t>>(data1, data2);
     }
 
     TEST(test_swap)
     {
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> compare1(0x2A);
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> compare2(0x15);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> compare1(0x2A);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> compare2(0x15);
 
-      ETL_CONSTEXPR14 std::pair<etl::bitset<8, int8_t>, etl::bitset<8, int8_t>> swapped = test_swap_helper();
+      ETL_CONSTEXPR14 std::pair<etl::bitset<8, uint8_t>, etl::bitset<8, uint8_t>> swapped = test_swap_helper();
 
       CHECK(swapped.first == compare2);
       CHECK(swapped.second == compare1);
@@ -1661,9 +1781,9 @@ namespace
     //*************************************************************************
     TEST(test_const_span)
     {
-      using span_t = etl::bitset<32, int32_t>::const_span_type;
+      using span_t = etl::bitset<32, uint32_t>::const_span_type;
 
-      const etl::bitset<32, int32_t> b(0x12345678UL);
+      const etl::bitset<32, uint32_t> b(0x12345678UL);
 
       span_t s = b.span();
       CHECK_EQUAL(0x12345678UL, s[0]);
@@ -1672,7 +1792,7 @@ namespace
     //*************************************************************************
     TEST(test_to_string)
     {
-      using bs32 = etl::bitset<32, int32_t>;
+      using bs32 = etl::bitset<32, uint32_t>;
 
       ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
@@ -1687,7 +1807,7 @@ namespace
     //*************************************************************************
     TEST(test_to_wstring)
     {
-      using bs32 = etl::bitset<32, int32_t>;
+      using bs32 = etl::bitset<32, uint32_t>;
 
       ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
@@ -1701,7 +1821,7 @@ namespace
     //*************************************************************************
     TEST(test_to_u16string)
     {
-      using bs32 = etl::bitset<32, int32_t>;
+      using bs32 = etl::bitset<32, uint32_t>;
 
       ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
@@ -1715,7 +1835,7 @@ namespace
     //*************************************************************************
     TEST(test_to_u32string)
     {
-      using bs32 = etl::bitset<32, int32_t>;
+      using bs32 = etl::bitset<32, uint32_t>;
 
       ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
@@ -1726,7 +1846,7 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
 
-    //*************************************************************************
+    ////*************************************************************************
     TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);

From 78d2ccf55ee5d3b1560a9ce4f337a1d8a43a182a Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Fri, 29 Dec 2023 16:00:10 +0000
Subject: [PATCH 16/26] Work in progress

Finished updating explicit single element tests for bitset_ext
---
 include/etl/private/bitset_new.h              | 240 ++---
 ...itset_new_explicit_single_element_type.cpp |  32 +
 ...t_new_ext_explicit_single_element_type.cpp | 977 +++++++++++-------
 3 files changed, 688 insertions(+), 561 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 7a766f64..7a4a7fa1 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -45,11 +45,16 @@ SOFTWARE.
 #include "../error_handler.h"
 #include "../span.h"
 #include "../string.h"
+#include "../enum_type.h"
 
 #include <string.h>
 #include <stddef.h>
 #include <stdint.h>
 
+#if ETL_USING_STL
+#include <algorithm>
+#endif
+
 #include "minmax_push.h"
 
 #if defined(ETL_COMPILER_KEIL)
@@ -76,71 +81,6 @@ SOFTWARE.
 
 namespace etl
 {
-  //namespace private_bitset
-  //{
-  //  //***************************************************************************
-  //  /// Common definitions for etl::bitset_impl
-  //  ///\ingroup bitset
-  //  //***************************************************************************
-  //  template <typename TElement>
-  //  struct bitset_impl_common
-  //  {
-  //    typedef TElement            element_type;
-  //    typedef element_type* pointer;
-  //    typedef const element_type* const_pointer;
-
-  //    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
-
-  //    static ETL_CONSTANT size_t       Bits_Per_Element  = etl::integral_limits<element_type>::bits;
-  //    static ETL_CONSTANT element_type All_Set_Element   = etl::integral_limits<element_type>::max;
-  //    static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
-  //  };
-
-  //  template <typename TElement>
-  //  ETL_CONSTANT size_t bitset_impl_common<TElement>::npos;
-
-  //  template <typename TElement>
-  //  ETL_CONSTANT size_t bitset_impl_common<TElement>::Bits_Per_Element;
-
-  //  template <typename TElement>
-  //  ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Set_Element;
-
-  //  template <typename TElement>
-  //  ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Clear_Element;
-
-  //  //***************************************************************************
-  //  /// Common definitions for etl::bitset
-  //  ///\ingroup bitset
-  //  //***************************************************************************
-  //  template <size_t Active_Bits, typename TElement>
-  //  struct bitset_common : public bitset_impl_common<TElement>
-  //  {
-  //    typedef TElement element_type;
-
-  //    static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
-  //    static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-  //    static ETL_CONSTANT size_t       Top_Mask_Shift     = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-  //    static ETL_CONSTANT element_type Top_Mask           = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
-
-  //    static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
-
-  //    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-  //    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
-  //  };
-
-  //  template <size_t Active_Bits, typename TElement>
-  //  ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Number_Of_Elements;
-
-  //  template <size_t Active_Bits, typename TElement>
-  //  ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Allocated_Bits;
-
-  //  template <size_t Active_Bits, typename TElement>
-  //  ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Top_Mask_Shift;
-
-  //  template <size_t Active_Bits, typename TElement>
-  //  ETL_CONSTANT typename bitset_common<Active_Bits, TElement>::element_type private_bitset::bitset_common<Active_Bits, TElement>::Top_Mask;
-  //}
-
   //***************************************************************************
   /// Flags to indicate whether the bitset is contained in a single element
   /// or spread over an array of elements.
@@ -148,8 +88,9 @@ namespace etl
   //***************************************************************************
   struct bitset_layout
   {
-    static ETL_CONSTANT bool Single = true;
-    static ETL_CONSTANT bool Multi  = false;
+    static ETL_CONSTANT char Undefined = 0;
+    static ETL_CONSTANT char Single    = 1;
+    static ETL_CONSTANT char Multi     = 2;
   };
 
   //***************************************************************************
@@ -212,7 +153,7 @@ namespace etl
   /// Bitset implementation declaration.
   ///\ingroup bitset
   //*************************************************************************
-  template <typename TElement, bool Bitset_Layout>
+  template <typename TElement, char Bitset_Layout>
   class bitset_impl;
 
   //*************************************************************************
@@ -224,16 +165,14 @@ namespace etl
   {
   public:
 
-    //static ETL_CONSTANT bool Element_Layout = etl::bitset_layout::Single;
-
     typedef TElement            element_type;
     typedef element_type*       pointer;
     typedef const element_type* const_pointer;
 
     static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
 
-    static ETL_CONSTANT size_t       Bits_Per_Element = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits<element_type>::max;
+    static ETL_CONSTANT size_t       Bits_Per_Element  = etl::integral_limits<element_type>::bits;
+    static ETL_CONSTANT element_type All_Set_Element   = etl::integral_limits<element_type>::max;
     static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
 
     //*************************************************************************
@@ -241,10 +180,11 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 
     static 
-    void set(pointer pbuffer, 
-             size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    void set(pointer      pbuffer,
+             size_t       /*number_of_elements*/,
+             element_type top_mask) ETL_NOEXCEPT
     {
-      *pbuffer = All_Set_Element;
+      *pbuffer = All_Set_Element & top_mask;
     }
 
     //*************************************************************************
@@ -303,11 +243,9 @@ namespace etl
                      size_t      active_bits, 
                      const char* text) ETL_NOEXCEPT
     {
-      if (text == ETL_NULLPTR)
-      {
-        reset(pbuffer, 1U);
-      }
-      else
+      reset(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
       {
         size_t string_length = etl::strlen(text);
 
@@ -322,10 +260,6 @@ namespace etl
           {
             *pbuffer |= mask;
           }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
 
           mask >>= 1U;
         }
@@ -342,11 +276,9 @@ namespace etl
                      size_t         active_bits, 
                      const wchar_t* text) ETL_NOEXCEPT
     {
-      if (text == ETL_NULLPTR)
-      {
-        reset(pbuffer, 1U);
-      }
-      else
+      reset(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
       {
         size_t string_length = etl::strlen(text);
 
@@ -361,10 +293,6 @@ namespace etl
           {
             *pbuffer |= mask;
           }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
 
           mask >>= 1U;
         }
@@ -381,11 +309,9 @@ namespace etl
                      size_t          active_bits, 
                      const char16_t* text) ETL_NOEXCEPT
     {
-      if (text == ETL_NULLPTR)
-      {
-        reset(pbuffer, 1U);
-      }
-      else
+      reset(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
       {
         size_t string_length = etl::strlen(text);
 
@@ -400,10 +326,6 @@ namespace etl
           {
             *pbuffer |= mask;
           }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
 
           mask >>= 1U;
         }
@@ -420,11 +342,9 @@ namespace etl
                      size_t          active_bits, 
                      const char32_t* text) ETL_NOEXCEPT
     {
-      if (text == ETL_NULLPTR)
-      {
-        reset(pbuffer, 1U);
-      }
-      else
+      reset(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
       {
         size_t string_length = etl::strlen(text);
 
@@ -439,10 +359,6 @@ namespace etl
           {
             *pbuffer |= mask;
           }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
 
           mask >>= 1U;
         }
@@ -725,6 +641,7 @@ namespace etl
 
     //*************************************************************************
     /// operator assignment
+    /// Assigns rhs to lhs
     //*************************************************************************
     ETL_CONSTEXPR14 
     static 
@@ -737,6 +654,7 @@ namespace etl
 
     //*************************************************************************
     /// operator and
+    /// AND lhs and rhs and put the result in lhs
     //*************************************************************************
     ETL_CONSTEXPR14 
     static 
@@ -749,6 +667,7 @@ namespace etl
 
     //*************************************************************************
     /// operator or
+    /// OR lhs and rhs and put the result in lhs
     //*************************************************************************
     ETL_CONSTEXPR14 
     static 
@@ -761,6 +680,7 @@ namespace etl
 
     //*************************************************************************
     /// operator xor
+    /// XOR lhs and rhs and put the result in lhs
     //*************************************************************************
     ETL_CONSTEXPR14 
     static 
@@ -773,6 +693,7 @@ namespace etl
 
     //*************************************************************************
     /// operator ~
+    /// NOT the value in the buffer
     //*************************************************************************
     ETL_CONSTEXPR14 
     static 
@@ -855,15 +776,12 @@ namespace etl
               pointer rhs_pbuffer, 
               size_t  /*number_of_elements*/) ETL_NOEXCEPT
     {
-      using ETL_OR_STD::iter_swap;
-
-      iter_swap(lhs_pbuffer, rhs_pbuffer);
+      element_type temp = *lhs_pbuffer;
+      *lhs_pbuffer = *rhs_pbuffer;
+      *rhs_pbuffer = temp;
     }
   };
 
-  //template <typename TElement>
-  //ETL_CONSTANT bool etl::bitset_impl<TElement, etl::bitset_layout::Single>::Element_Layout;
-
   //*************************************************************************
   /// The implementation class for multi element etl::bitset
   ///\ingroup bitset
@@ -883,8 +801,6 @@ namespace etl
     static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits<element_type>::max;
     static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
 
-    //static ETL_CONSTANT bool Element_Layout = etl::bitset_layout::Multi;
-
     //*************************************************************************
     /// Check to see if the requested extract is contained within one element.
     //*************************************************************************
@@ -1756,9 +1672,6 @@ namespace etl
     }
   };
 
-  //template <typename TElement>
-  //ETL_CONSTANT bool etl::bitset_impl<TElement, etl::bitset_layout::Multi>::Element_Layout;
-
   //***************************************************************************
   /// Bitset forward declaration
   //***************************************************************************
@@ -1784,8 +1697,7 @@ namespace etl
     static ETL_CONSTANT size_t       Allocated_Bits     = 0U;
     static ETL_CONSTANT element_type All_Set_Element    = 0U;
     static ETL_CONSTANT element_type All_Clear_Element  = 0U;
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
-    static ETL_CONSTANT element_type Top_Mask           = 0U;
+    static ETL_CONSTANT char         Element_Layout     = etl::bitset_layout::Undefined;
 
     static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
   };
@@ -1806,15 +1718,19 @@ namespace etl
 
     static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
 
-    //static ETL_CONSTANT bool Element_Layout = implementation::Element_Layout;
-
     static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
     static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
     static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
     static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
     static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-    static ETL_CONSTANT element_type Top_Mask           = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+    static ETL_CONSTANT char         Element_Layout     = (Number_Of_Elements == 1U) ? etl::bitset_layout::Single : etl::bitset_layout::Multi;
+
+  private:
+    
+    static ETL_CONSTANT size_t       Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
+    static ETL_CONSTANT element_type Top_Mask       = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+
+  public:
 
     static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
 
@@ -1910,6 +1826,7 @@ namespace etl
     /// Default constructor.
     //*************************************************************************
     ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT
+      : buffer()
     {
       implementation::reset(buffer, Number_Of_Elements);
     }
@@ -1973,7 +1890,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      etl::copy_n(other.buffer, Number_Of_Elements, buffer);
+      implementation::operator_assignment(buffer, other.buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -1983,7 +1900,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set() ETL_NOEXCEPT
     {
-      implementation::set(buffer, Number_Of_Elements);
+      implementation::set(buffer, Number_Of_Elements, Top_Mask);
 
       return *this;
     }
@@ -2454,9 +2371,7 @@ namespace etl
     //*************************************************************************
     friend ETL_CONSTEXPR14 bool operator ==(const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
     {
-      return etl::equal(lhs.buffer, 
-                        lhs.buffer + lhs.Number_Of_Elements,
-                        rhs.buffer);
+      return implementation::operator_equality(lhs.buffer, rhs.buffer, lhs.Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2586,8 +2501,7 @@ namespace etl
     static ETL_CONSTANT size_t       Allocated_Bits     = 0U;
     static ETL_CONSTANT element_type All_Set_Element    = 0U;
     static ETL_CONSTANT element_type All_Clear_Element  = 0U;
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
-    static ETL_CONSTANT element_type Top_Mask           = 0U;
+    static ETL_CONSTANT char         Element_Layout     = etl::bitset_layout::Undefined;
 
     static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
   };
@@ -2596,7 +2510,7 @@ namespace etl
   /// The specialisation that uses an array of the default element type.
   //*************************************************************************
   template <size_t Active_Bits, typename TElement>
-  class bitset_ext// : public etl::private_bitset::bitset_common<Active_Bits, TEelement>
+  class bitset_ext
   {
   public:
 
@@ -2608,15 +2522,19 @@ namespace etl
 
     static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
 
-    //static ETL_CONSTANT bool Element_Layout = implementation::Element_Layout;
-
     static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
     static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
     static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
     static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
     static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-    static ETL_CONSTANT element_type Top_Mask           = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+    static ETL_CONSTANT char         Element_Layout     = (Number_Of_Elements == 1U) ? etl::bitset_layout::Single : etl::bitset_layout::Multi;
+
+  private:
+
+    static ETL_CONSTANT size_t       Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
+    static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+
+  public:
 
     static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
 
@@ -2716,7 +2634,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      reset();
+      implementation::reset(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2726,7 +2644,7 @@ namespace etl
       : pbuffer(buffer.data())
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      reset();
+      implementation::reset(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2736,7 +2654,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
+      implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2745,7 +2663,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement>& other, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
+      implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2779,7 +2697,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2788,7 +2706,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2798,7 +2716,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2807,7 +2725,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2817,7 +2735,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2826,7 +2744,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2836,7 +2754,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2845,7 +2763,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
@@ -2863,7 +2781,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set() ETL_NOEXCEPT
     {
-      implementation::set(pbuffer, Number_Of_Elements, All_Set_Element);
+      implementation::set(pbuffer, Number_Of_Elements, Top_Mask);
 
       return *this;
     }
@@ -2885,7 +2803,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char* text) ETL_NOEXCEPT
     {
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2895,7 +2813,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const wchar_t* text) ETL_NOEXCEPT
     {
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2905,7 +2823,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char16_t* text) ETL_NOEXCEPT
     {
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2915,7 +2833,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char32_t* text) ETL_NOEXCEPT
     {
-      implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3108,7 +3026,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
     {
-      return implementation::any(pbuffer, Number_Of_Elements, Top_Mask);
+      return implementation::any(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -3116,7 +3034,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
     {
-      return implementation::any(pbuffer, Number_Of_Elements, Top_Mask, mask);
+      return implementation::any(pbuffer, Number_Of_Elements, mask);
     }
 
     //*************************************************************************
@@ -3217,7 +3135,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator ^=(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      implementation::xoperator_or(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
+      implementation::operator_xor(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -3247,7 +3165,7 @@ namespace etl
     //*************************************************************************
     friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext<Active_Bits, TElement>& lhs, const bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
     {
-      return etl::equal(lhs.pbuffer, lhs.pbuffer + lhs.Number_Of_Elements, rhs.pbuffer);
+      return implementation::operator_equality(lhs.pbuffer, rhs.pbuffer, lhs.Number_Of_Elements);
     }
 
     //*************************************************************************
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index 291c6836..18d19157 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -146,6 +146,11 @@ namespace
       CHECK_EQUAL(1U, data16.Number_Of_Elements);
       CHECK_EQUAL(1U, data32.Number_Of_Elements);
       CHECK_EQUAL(1U, data64.Number_Of_Elements);
+
+      CHECK_EQUAL(etl::bitset_layout::Single, data8.Element_Layout);
+      CHECK_EQUAL(etl::bitset_layout::Single, data16.Element_Layout);
+      CHECK_EQUAL(etl::bitset_layout::Single, data32.Element_Layout);
+      CHECK_EQUAL(etl::bitset_layout::Single, data64.Element_Layout);
     }
 
     //*************************************************************************
@@ -353,6 +358,33 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_set_less_than_full_size)
+    {
+      std::bitset<60> compare;
+      etl::bitset<60, uint64_t> data;
+
+      compare.set();
+      data.set();
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
     //*************************************************************************
     TEST(test_set_with_char_string)
     {
diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp
index 4b3d3948..cbba1ed4 100644
--- a/test/test_bitset_new_ext_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp
@@ -47,7 +47,7 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_nullptr_buffer)
     {
-      using BsExt = etl::bitset_ext<64, int64_t>;
+      using BsExt = etl::bitset_ext<64, uint64_t>;
 
       BsExt::buffer_type buffer;
       BsExt bs2a(buffer);
@@ -64,9 +64,9 @@ namespace
     //*************************************************************************
     TEST(test_default_constructor_from_array)
     {
-      etl::bitset_ext<64, int64_t>::element_type buffer[etl::bitset_ext<64, int64_t>::Number_Of_Elements];
+      etl::bitset_ext<64, uint64_t>::element_type buffer[etl::bitset_ext<64, uint64_t>::Number_Of_Elements];
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -80,9 +80,9 @@ namespace
     //*************************************************************************
     TEST(test_default_constructor_from_buffer_type)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -96,28 +96,33 @@ namespace
     //*************************************************************************
     TEST(test_default_constructor_single_element)
     {
-      etl::bitset_ext<8,  int8_t>::buffer_type  buffer8;
-      etl::bitset_ext<16, int16_t>::buffer_type buffer16;
-      etl::bitset_ext<32, int32_t>::buffer_type buffer32;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer64;
+      etl::bitset_ext<8,  uint8_t>::buffer_type  buffer8;
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer16;
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer32;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer64;
 
-      etl::bitset_ext<8,  int8_t>  data8(buffer8);
-      etl::bitset_ext<16, int16_t> data16(buffer16);
-      etl::bitset_ext<32, int32_t> data32(buffer32);
-      etl::bitset_ext<64, int64_t> data64(buffer64);
+      etl::bitset_ext<8,  uint8_t>  data8(buffer8);
+      etl::bitset_ext<16, uint16_t> data16(buffer16);
+      etl::bitset_ext<32, uint32_t> data32(buffer32);
+      etl::bitset_ext<64, uint64_t> data64(buffer64);
 
       CHECK_EQUAL(1U, data8.Number_Of_Elements);
       CHECK_EQUAL(1U, data16.Number_Of_Elements);
       CHECK_EQUAL(1U, data32.Number_Of_Elements);
       CHECK_EQUAL(1U, data64.Number_Of_Elements);
+
+      CHECK_EQUAL(etl::bitset_layout::Single, data8.Element_Layout);
+      CHECK_EQUAL(etl::bitset_layout::Single, data16.Element_Layout);
+      CHECK_EQUAL(etl::bitset_layout::Single, data32.Element_Layout);
+      CHECK_EQUAL(etl::bitset_layout::Single, data64.Element_Layout);
     }
 
     //*************************************************************************
     TEST(test_construct_from_value)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
       std::bitset<64> compare(0x123456731234567ULL);
-      etl::bitset_ext<64, int64_t> data(0x123456731234567ULL, buffer1);
+      etl::bitset_ext<64, uint64_t> data(0x123456731234567ULL, buffer1);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -132,11 +137,11 @@ namespace
     //*************************************************************************
     TEST(test_copy_construct)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
       std::bitset<64> compare(0x123456731234567ULL);
-      etl::bitset_ext<64, int64_t> data(0x123456731234567ULL, buffer1);
-      etl::bitset_ext<64, int64_t> data_copy(data, buffer2);
+      etl::bitset_ext<64, uint64_t> data(0x123456731234567ULL, buffer1);
+      etl::bitset_ext<64, uint64_t> data_copy(data, buffer2);
 
       CHECK_EQUAL(compare.size(), data_copy.size());
       CHECK_EQUAL(compare.count(), data_copy.count());
@@ -150,9 +155,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_excess_value)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(0x8765432187654321ULL);
-      etl::bitset_ext<64, int64_t> data(0x8765432187654321ULL, buffer);
+      etl::bitset_ext<64, uint64_t> data(0x8765432187654321ULL, buffer);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -166,9 +171,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -182,9 +187,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_wchar_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(L"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64, uint64_t> data(L"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -198,9 +203,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char16_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(u"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64, uint64_t> data(u"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -214,9 +219,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char32_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(U"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64, uint64_t> data(U"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -232,8 +237,8 @@ namespace
     {
       const char* s = nullptr;
 
-      etl::bitset_ext<60, int64_t>::buffer_type buffer;
-      etl::bitset_ext<60, int64_t> data(s, buffer);
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(s, buffer);
 
       CHECK_EQUAL(60, data.size());
       CHECK_EQUAL(0, data.count());
@@ -244,8 +249,8 @@ namespace
     {
       const wchar_t* s = nullptr;
 
-      etl::bitset_ext<60, int64_t>::buffer_type buffer;
-      etl::bitset_ext<60, int64_t> data(s, buffer);
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(s, buffer);
 
       CHECK_EQUAL(60, data.size());
       CHECK_EQUAL(0, data.count());
@@ -256,8 +261,8 @@ namespace
     {
       const char16_t* s = nullptr;
 
-      etl::bitset_ext<60, int64_t>::buffer_type buffer;
-      etl::bitset_ext<60, int64_t> data(s, buffer);
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(s, buffer);
 
       CHECK_EQUAL(60, data.size());
       CHECK_EQUAL(0, data.count());
@@ -268,8 +273,8 @@ namespace
     {
       const char32_t* s = nullptr;
 
-      etl::bitset_ext<60, int64_t>::buffer_type buffer;
-      etl::bitset_ext<60, int64_t> data(s, buffer);
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(s, buffer);
 
       CHECK_EQUAL(60, data.size());
       CHECK_EQUAL(0, data.count());
@@ -278,9 +283,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_excess_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001");
-      etl::bitset_ext<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer);
+      etl::bitset_ext<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -299,9 +304,9 @@ namespace
     //*************************************************************************
     TEST(test_set)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       compare.set();
       data.set();
@@ -324,12 +329,40 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_set_less_than_full_size)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      std::bitset<60> compare;
+      etl::bitset_ext<60, uint64_t> data(buffer);
+
+      compare.set();
+      data.set();
+
+      auto size = data.size();
+      auto count = data.count();
+      auto none = data.none();
+      auto any = data.any();
+      auto all = data.all();
+
+      CHECK_EQUAL(compare.size(), size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(), none);
+      CHECK_EQUAL(compare.any(), any);
+      CHECK_EQUAL(compare.all(), all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
     //*************************************************************************
     TEST(test_set_with_char_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.set("110001001000110100010101100111001100010010001101000101011001");
 
@@ -348,9 +381,9 @@ namespace
     //*************************************************************************
     TEST(test_set_with_wchar_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.set(L"110001001000110100010101100111001100010010001101000101011001");
 
@@ -369,9 +402,9 @@ namespace
     //*************************************************************************
     TEST(test_set_with_char16_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.set(u"110001001000110100010101100111001100010010001101000101011001");
 
@@ -390,9 +423,9 @@ namespace
     //*************************************************************************
     TEST(test_set_with_char32_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.set(U"110001001000110100010101100111001100010010001101000101011001");
 
@@ -413,8 +446,8 @@ namespace
     {
       const char* s = nullptr;
 
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
       data.set(s);
 
       CHECK_EQUAL(64, data.size());
@@ -426,8 +459,8 @@ namespace
     {
       const wchar_t* s = nullptr;
 
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
       data.set(s);
 
       CHECK_EQUAL(64, data.size());
@@ -439,8 +472,8 @@ namespace
     {
       const char16_t* s = nullptr;
 
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
       data.set(s);
 
       CHECK_EQUAL(64, data.size());
@@ -452,8 +485,8 @@ namespace
     {
       const char32_t* s = nullptr;
 
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
       data.set(s);
 
       CHECK_EQUAL(64, data.size());
@@ -463,9 +496,9 @@ namespace
     //*************************************************************************
     TEST(test_from_string_with_char)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.from_string("110001001000110100010101100111001100010010001101000101011001");
 
@@ -484,9 +517,9 @@ namespace
     //*************************************************************************
     TEST(test_from_string_with_wchar_t)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.from_string(L"110001001000110100010101100111001100010010001101000101011001");
 
@@ -505,9 +538,9 @@ namespace
     //*************************************************************************
     TEST(test_from_string_with_char16_t)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.from_string(u"110001001000110100010101100111001100010010001101000101011001");
 
@@ -526,9 +559,9 @@ namespace
     //*************************************************************************
     TEST(test_from_string_with_char32_t)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.from_string(U"110001001000110100010101100111001100010010001101000101011001");
 
@@ -549,8 +582,8 @@ namespace
     {
       const char* s = nullptr;
 
-      etl::bitset_ext<60, int64_t>::buffer_type buffer;
-      etl::bitset_ext<60, int64_t> data(buffer);
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(buffer);
       data.from_string(s);
 
       CHECK_EQUAL(60, data.size());
@@ -562,8 +595,8 @@ namespace
     {
       const wchar_t* s = nullptr;
 
-      etl::bitset_ext<60, int64_t>::buffer_type buffer;
-      etl::bitset_ext<60, int64_t> data(buffer);
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(buffer);
       data.from_string(s);
 
       CHECK_EQUAL(60, data.size());
@@ -575,8 +608,8 @@ namespace
     {
       const char16_t* s = nullptr;
 
-      etl::bitset_ext<60, int64_t>::buffer_type buffer;
-      etl::bitset_ext<60, int64_t> data(buffer);
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(buffer);
       data.from_string(s);
 
       CHECK_EQUAL(60, data.size());
@@ -588,8 +621,8 @@ namespace
     {
       const char16_t* s = nullptr;
 
-      etl::bitset_ext<60, int64_t>::buffer_type buffer;
-      etl::bitset_ext<60, int64_t> data(buffer);
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(buffer);
       data.from_string(s);
 
       CHECK_EQUAL(60, data.size());
@@ -599,8 +632,8 @@ namespace
     //*************************************************************************
     TEST(test_value_u8_min)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
-      etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits<uint8_t>::min, buffer);
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits<uint8_t>::min, buffer);
       uint8_t value = data.value<uint8_t>();
 
       CHECK_EQUAL(std::numeric_limits<uint8_t>::min(), value);
@@ -609,8 +642,8 @@ namespace
     //*************************************************************************
     TEST(test_value_u8_max)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
-      etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits<uint8_t>::max, buffer);
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits<uint8_t>::max, buffer);
       uint8_t value = data.value<uint8_t>();
 
       CHECK_EQUAL(std::numeric_limits<uint8_t>::max(), value);
@@ -619,28 +652,28 @@ namespace
     //*************************************************************************
     TEST(test_value_s8_min)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
-      etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits<int8_t>::min, buffer);
-      int8_t value = data.value<int8_t>();
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits<uint8_t>::min, buffer);
+      uint8_t value = data.value<uint8_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int8_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s8_max)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
-      etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits<int8_t>::max, buffer);
-      int8_t value = data.value<int8_t>();
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits<uint8_t>::max, buffer);
+      uint8_t value = data.value<uint8_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int8_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u16_min)
     {
-      etl::bitset_ext<16, int16_t>::buffer_type buffer;
-      etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits<uint16_t>::min, buffer);
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+      etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits<uint16_t>::min, buffer);
       uint16_t value = data.value<uint16_t>();
 
       CHECK_EQUAL(std::numeric_limits<uint16_t>::min(), value);
@@ -649,8 +682,8 @@ namespace
     //*************************************************************************
     TEST(test_value_u16_max)
     {
-      etl::bitset_ext<16, int16_t>::buffer_type buffer;
-      etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits<uint16_t>::max, buffer);
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+      etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits<uint16_t>::max, buffer);
       uint16_t value = data.value<uint16_t>();
 
       CHECK_EQUAL(std::numeric_limits<uint16_t>::max(), value);
@@ -659,109 +692,109 @@ namespace
     //*************************************************************************
     TEST(test_value_s16_min)
     {
-      etl::bitset_ext<16, int16_t>::buffer_type buffer;
-      etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits<int16_t>::min, buffer);
-      int16_t value = data.value<int16_t>();
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+      etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits<uint16_t>::min, buffer);
+      uint16_t value = data.value<uint16_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int16_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint16_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s16_max)
     {
-      etl::bitset_ext<16, int16_t>::buffer_type buffer;
-      etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits<int16_t>::max, buffer);
-      int16_t value = data.value<int16_t>();
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+      etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits<uint16_t>::max, buffer);
+      uint16_t value = data.value<uint16_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int16_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint16_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u32_min)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer;
-      etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits<int32_t>::min, buffer);
-      int32_t value = data.value<int32_t>();
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer;
+      etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits<uint32_t>::min, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int32_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u32_max)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer;
-      etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits<int32_t>::max, buffer);
-      int32_t value = data.value<int32_t>();
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer;
+      etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits<uint32_t>::max, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int32_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s32_min)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer;
-      etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits<int32_t>::min, buffer);
-      int32_t value = data.value<int32_t>();
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer;
+      etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits<uint32_t>::min, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int32_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s32_max)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer;
-      etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits<int32_t>::max, buffer);
-      int32_t value = data.value<int32_t>();
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer;
+      etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits<uint32_t>::max, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int32_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u64_min)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits<int64_t>::min, buffer);
-      int64_t value = data.value<int64_t>();
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits<uint64_t>::min, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u64_max)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits<int64_t>::max, buffer);
-      int64_t value = data.value<int64_t>();
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits<uint64_t>::max, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s64_min)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits<int64_t>::min, buffer);
-      int64_t value = data.value<int64_t>();
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits<uint64_t>::min, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s64_max)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits<int64_t>::max, buffer);
-      int64_t value = data.value<int64_t>();
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits<uint64_t>::max, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_position_set)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -793,9 +826,9 @@ namespace
     //*************************************************************************
     TEST(test_reset)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<64, int64_t> data(0xFFFFFFFFFFFFFFFULL, buffer);
+      etl::bitset_ext<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL, buffer);
 
       compare.reset();
       data.reset();
@@ -815,9 +848,9 @@ namespace
     //*************************************************************************
     TEST(test_position_reset)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<64, int64_t> data(0xFFFFFFFFFFFFFFFULL, buffer);
+      etl::bitset_ext<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL, buffer);
 
       compare.reset(1);
       compare.reset(3);
@@ -871,9 +904,9 @@ namespace
     //*************************************************************************
     TEST(test_index_operator_read)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(0x3123456731234567ULL);
-      etl::bitset_ext<64, int64_t> data(0x3123456731234567ULL, buffer);
+      etl::bitset_ext<64, uint64_t> data(0x3123456731234567ULL, buffer);
 
       bool bc0 = compare[1U];
       bool bd0 = data[1U];
@@ -895,8 +928,8 @@ namespace
     //*************************************************************************
     TEST(test_index_operator_write)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data[1U]  = true;
       data[3U]  = true;
@@ -912,14 +945,14 @@ namespace
     //*************************************************************************
     TEST(test_any)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.any();
       bool bd2 = data2.any();
@@ -935,14 +968,14 @@ namespace
     //*************************************************************************
     TEST(test_any_with_mask)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0xF000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0xF000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -960,14 +993,14 @@ namespace
     //*************************************************************************
     TEST(test_none)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.none();
       bool bd2 = data2.none();
@@ -983,14 +1016,14 @@ namespace
     //*************************************************************************
     TEST(test_none_with_mask)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0xF000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0xF000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -1008,14 +1041,14 @@ namespace
     //*************************************************************************
     TEST(test_all)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.all();
       bool bd2 = data2.all();
@@ -1031,14 +1064,14 @@ namespace
     //*************************************************************************
     TEST(test_all_with_mask)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4);
 
       ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -1053,12 +1086,156 @@ namespace
       CHECK_TRUE(bd4);
     }
 
+    //*************************************************************************
+    TEST(test_any_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.any();
+      bool bd2 = data2.any();
+      bool bd3 = data3.any();
+      bool bd4 = data4.any();
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_any_with_mask_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      ull mask = ull(0x0FFFFFFFFFFFFFFF);
+
+      bool bd1 = data1.any(mask);
+      bool bd2 = data2.any(mask);
+      bool bd3 = data3.any(mask);
+      bool bd4 = data4.any(mask);
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.none();
+      bool bd2 = data2.none();
+      bool bd3 = data3.none();
+      bool bd4 = data4.none();
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_mask_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      ull mask = ull(0x0FFFFFFFFFFFFFFF);
+
+      bool bd1 = data1.none(mask);
+      bool bd2 = data2.none(mask);
+      bool bd3 = data3.none(mask);
+      bool bd4 = data4.none(mask);
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.all();
+      bool bd2 = data2.all();
+      bool bd3 = data3.all();
+      bool bd4 = data4.all();
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_mask_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      ull mask = ull(0x00FFFFFFFFFFFFFF);
+
+      bool bd1 = data1.all(mask);
+      bool bd2 = data2.all(mask);
+      bool bd3 = data3.all(mask);
+      bool bd4 = data4.all(mask);
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
     //*************************************************************************
     TEST(test_flip)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       compare.flip();
       data.flip();
@@ -1072,9 +1249,9 @@ namespace
     //*************************************************************************
     TEST(test_flip_position)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       compare.flip(1);
       compare.flip(3);
@@ -1095,9 +1272,9 @@ namespace
     //*************************************************************************
     TEST(test_flip_reference)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       compare[1].flip();
       compare[3].flip();
@@ -1118,9 +1295,9 @@ namespace
     //*************************************************************************
     TEST(test_invert_reference)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       bool bc = ~compare[3];
       bool bd = ~data[3];
@@ -1128,18 +1305,18 @@ namespace
     }
 
     //*************************************************************************
-    void test_assignment_operator_helper(etl::bitset_ext<64, int64_t>& from, etl::bitset_ext<64, int64_t>& to)
+    void test_assignment_operator_helper(etl::bitset_ext<64, uint64_t>& from, etl::bitset_ext<64, uint64_t>& to)
     {
       to = from;
     }
 
     TEST(test_assignment_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
       std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<64, int64_t> data1(0xFFFFFFFFFFFFFFFULL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(buffer2);
+      etl::bitset_ext<64, uint64_t> data1(0xFFFFFFFFFFFFFFFULL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(buffer2);
 
       test_assignment_operator_helper(data1, data2);
 
@@ -1152,12 +1329,12 @@ namespace
     //*************************************************************************
     TEST(test_equality_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t> data1(0x123456781234567ULL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(0x123456781234567ULL, buffer2);
-      etl::bitset_ext<64, int64_t> data3(buffer3);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t> data1(0x123456781234567ULL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(0x123456781234567ULL, buffer2);
+      etl::bitset_ext<64, uint64_t> data3(buffer3);
 
       bool equal     =  (data1 == data2);
       bool not_equal = !(data1 == data3);
@@ -1169,12 +1346,12 @@ namespace
     //*************************************************************************
     TEST(test_inequality_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t> data1(0x123456781234567ULL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(0x123456781234567ULL, buffer2);
-      etl::bitset_ext<64, int64_t> data3(buffer3);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t> data1(0x123456781234567ULL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(0x123456781234567ULL, buffer2);
+      etl::bitset_ext<64, uint64_t> data3(buffer3);
 
       bool equal     = !(data1 != data2);
       bool not_equal = (data1 != data3);
@@ -1186,71 +1363,71 @@ namespace
     //*************************************************************************
     TEST(test_shift_left_operator)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
       uint64_t mask = 0xFFFFFFFFFFFFFFFFULL;
 
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
 
-      etl::bitset_ext<64, int64_t> original(0x0123456789ABCDEFULL, buffer1);
+      etl::bitset_ext<64, uint64_t> original(0x0123456789ABCDEFULL, buffer1);
 
       for (ull shift = 0U; shift < 64U; ++shift)
       {
-        etl::bitset_ext<64, int64_t> data(original, buffer2);
-        CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value<int64_t>());
+        etl::bitset_ext<64, uint64_t> data(original, buffer2);
+        CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value<uint64_t>());
         mask >>= 1;
       }
 
-      etl::bitset_ext<64, int64_t> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value<int64_t>());
+      etl::bitset_ext<64, uint64_t> data(original, buffer2);
+      CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value<uint64_t>());
     }
 
     //*************************************************************************
     TEST(test_shift_left_operator_overflow)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer1;
-      etl::bitset_ext<32, int32_t>::buffer_type buffer2;
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer1;
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer2;
 
-      etl::bitset_ext<32, int32_t> data(0xFFFFFFFFULL, buffer1);
+      etl::bitset_ext<32, uint32_t> data(0xFFFFFFFFULL, buffer1);
       data <<= 1U;
-      etl::bitset_ext<32, int32_t> shifted(0xFFFFFFFEUL, buffer2);
+      etl::bitset_ext<32, uint32_t> shifted(0xFFFFFFFEUL, buffer2);
 
-      CHECK_EQUAL_HEX(shifted.value<int32_t>(), data.value<int32_t>());
+      CHECK_EQUAL_HEX(shifted.value<uint32_t>(), data.value<uint32_t>());
     }
 
     //*************************************************************************
     TEST(test_shift_right_operator)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
 
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
 
-      etl::bitset_ext<64, int64_t> original(0x0123456789ABCDEFULL, buffer1);
+      etl::bitset_ext<64, uint64_t> original(0x0123456789ABCDEFULL, buffer1);
       
       for (ull shift = 0U; shift < 64U; ++shift)
       {
-        etl::bitset_ext<64, int64_t> data(original, buffer2);
-        CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value<int64_t>());
+        etl::bitset_ext<64, uint64_t> data(original, buffer2);
+        CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value<uint64_t>());
       }
 
-      etl::bitset_ext<64, int64_t> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value<int64_t>());
+      etl::bitset_ext<64, uint64_t> data(original, buffer2);
+      CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value<uint64_t>());
     }
 
     //*************************************************************************
     TEST(test_and_equals_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
 
-      etl::bitset_ext<64, int64_t> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<64, int64_t> data3(0x12345678UL & 0x23456789UL, buffer3);
+      etl::bitset_ext<64, uint64_t> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64, uint64_t> data3(0x12345678UL & 0x23456789UL, buffer3);
 
-      etl::bitset_ext<64, int64_t> data4(data1, buffer4);
+      etl::bitset_ext<64, uint64_t> data4(data1, buffer4);
       data4 &= data2;
       CHECK(data3 == data4);
     }
@@ -1258,16 +1435,16 @@ namespace
     //*************************************************************************
     TEST(test_or_equals_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
 
-      etl::bitset_ext<64, int64_t> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<64, int64_t> data3(0x12345678UL | 0x23456789UL, buffer3);
+      etl::bitset_ext<64, uint64_t> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64, uint64_t> data3(0x12345678UL | 0x23456789UL, buffer3);
 
-      etl::bitset_ext<64, int64_t> data4(data1, buffer4);
+      etl::bitset_ext<64, uint64_t> data4(data1, buffer4);
       data4 |= data2;
       CHECK(data3 == data4);
     }
@@ -1275,16 +1452,16 @@ namespace
     //*************************************************************************
     TEST(test_xor_equals_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
 
-      etl::bitset_ext<64, int64_t> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<64, int64_t> data3(0x12345678UL ^ 0x23456789UL, buffer3);
+      etl::bitset_ext<64, uint64_t> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64, uint64_t> data3(0x12345678UL ^ 0x23456789UL, buffer3);
 
-      etl::bitset_ext<64, int64_t> data4(data1, buffer4);
+      etl::bitset_ext<64, uint64_t> data4(data1, buffer4);
       data4 ^= data2;
       CHECK(data3 == data4);
     }
@@ -1292,45 +1469,45 @@ namespace
     //*************************************************************************
     TEST(test_find_first)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
 
-      etl::bitset_ext<8, int8_t> bs1(ull(0x00), buffer);
+      etl::bitset_ext<8, uint8_t> bs1(ull(0x00), buffer);
       size_t bs1fff = bs1.find_first(false);
       size_t bs1fft = bs1.find_first(true);
       CHECK_EQUAL(0U, bs1fff);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fft);
 
-      etl::bitset_ext<8, int8_t> bs2(ull(0xFF), buffer);
+      etl::bitset_ext<8, uint8_t> bs2(ull(0xFF), buffer);
       size_t bs2fff = bs2.find_first(false);
       size_t bs2fft = bs2.find_first(true);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fff);
       CHECK_EQUAL(0U, bs2fft);
 
-      etl::bitset_ext<8, int8_t> bs3(ull(0x01), buffer);
+      etl::bitset_ext<8, uint8_t> bs3(ull(0x01), buffer);
       size_t bs3fff = bs3.find_first(false);
       size_t bs3fft = bs3.find_first(true);
       CHECK_EQUAL(1U, bs3fff);
       CHECK_EQUAL(0U, bs3fft);
 
-      etl::bitset_ext<8, int8_t> bs4(ull(0x20), buffer);
+      etl::bitset_ext<8, uint8_t> bs4(ull(0x20), buffer);
       size_t bs4fff = bs4.find_first(false);
       size_t bs4fft = bs4.find_first(true);
       CHECK_EQUAL(0U, bs4fff);
       CHECK_EQUAL(5U, bs4fft);
 
-      etl::bitset_ext<8, int8_t> bs5(ull(0x21), buffer);
+      etl::bitset_ext<8, uint8_t> bs5(ull(0x21), buffer);
       size_t bs5fff = bs5.find_first(false);
       size_t bs5fft = bs5.find_first(true);
       CHECK_EQUAL(1U, bs5fff);
       CHECK_EQUAL(0U, bs5fft);
 
-      etl::bitset_ext<8, int8_t> bs6(ull(0x0E), buffer);
+      etl::bitset_ext<8, uint8_t> bs6(ull(0x0E), buffer);
       size_t bs6fff = bs6.find_first(false);
       size_t bs6fft = bs6.find_first(true);
       CHECK_EQUAL(0U, bs6fff);
       CHECK_EQUAL(1U, bs6fft);
 
-      etl::bitset_ext<8, int8_t> bs7(ull(0x31), buffer);
+      etl::bitset_ext<8, uint8_t> bs7(ull(0x31), buffer);
       size_t bs7fff = bs7.find_first(false);
       size_t bs7fft = bs7.find_first(true);
       CHECK_EQUAL(1U, bs7fff);
@@ -1340,9 +1517,9 @@ namespace
     //*************************************************************************
     TEST(test_find_next)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
 
-      etl::bitset_ext<8, int8_t> bs1(ull(0x00), buffer);
+      etl::bitset_ext<8, uint8_t> bs1(ull(0x00), buffer);
       size_t bs1fnf0 = bs1.find_next(false, 0);
       size_t bs1fnf1 = bs1.find_next(false, 1);
       size_t bs1fnt2 = bs1.find_next(true, 2);
@@ -1350,7 +1527,7 @@ namespace
       CHECK_EQUAL(1U, bs1fnf1);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fnt2);
 
-      etl::bitset_ext<8, int8_t> bs2(ull(0xFF), buffer);
+      etl::bitset_ext<8, uint8_t> bs2(ull(0xFF), buffer);
       size_t bs2fnt0 = bs2.find_next(true, 0);
       size_t bs2fnt1 = bs2.find_next(true, 1);
       size_t bs2fnf2 = bs2.find_next(false, 2);
@@ -1358,7 +1535,7 @@ namespace
       CHECK_EQUAL(1U, bs2fnt1);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fnf2);
 
-      etl::bitset_ext<8, int8_t> bs3(ull(0x0E), buffer);
+      etl::bitset_ext<8, uint8_t> bs3(ull(0x0E), buffer);
       size_t bs3fnf0 = bs3.find_next(false, 0);
       size_t bs3fnt1 = bs3.find_next(true, 1);
       size_t bs3fnf2 = bs3.find_next(false, 2);
@@ -1366,7 +1543,7 @@ namespace
       CHECK_EQUAL(1U, bs3fnt1);
       CHECK_EQUAL(4U, bs3fnf2);
 
-      etl::bitset_ext<8, int8_t> bs4(ull(0x31), buffer);
+      etl::bitset_ext<8, uint8_t> bs4(ull(0x31), buffer);
       size_t bs4fnt0 = bs4.find_next(true, 0);
       size_t bs4fnf0 = bs4.find_next(false, 0);
       size_t bs4fnt1 = bs4.find_next(true, 1);
@@ -1378,15 +1555,15 @@ namespace
     //*************************************************************************
     TEST(test_swap)
     {
-      etl::bitset_ext<16, int16_t>::buffer_type buffer1;
-      etl::bitset_ext<16, int16_t>::buffer_type buffer2;
-      etl::bitset_ext<16, int16_t>::buffer_type buffer3;
-      etl::bitset_ext<16, int16_t>::buffer_type buffer4;
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer1;
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer2;
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer3;
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer4;
 
-      etl::bitset_ext<16, int16_t> compare1(0x2A, buffer1);
-      etl::bitset_ext<16, int16_t> compare2(0x15, buffer2);
-      etl::bitset_ext<16, int16_t> compare1a(0x2A, buffer3);
-      etl::bitset_ext<16, int16_t> compare2a(0x15, buffer4);
+      etl::bitset_ext<16, uint16_t> compare1(0x2A, buffer1);
+      etl::bitset_ext<16, uint16_t> compare2(0x15, buffer2);
+      etl::bitset_ext<16, uint16_t> compare1a(0x2A, buffer3);
+      etl::bitset_ext<16, uint16_t> compare2a(0x15, buffer4);
 
       swap(compare1a, compare2a);
 
@@ -1397,7 +1574,7 @@ namespace
     //*************************************************************************
     TEST(test_span)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer; 
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer; 
       etl::bitset_ext<32, uint32_t> data(0x12345678UL, buffer);
 
       using span_t = etl::bitset_ext<32, uint32_t>::span_type;
@@ -1409,7 +1586,7 @@ namespace
     //*************************************************************************
     TEST(test_const_span)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer;
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer;
       const etl::bitset_ext<32, uint32_t> data(0x12345678UL, buffer);
 
       using span_t = const etl::bitset_ext<32, uint32_t>::const_span_type;
@@ -1421,7 +1598,7 @@ namespace
     //*************************************************************************
     TEST(test_to_string)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 data(0x12345678UL, buffer);
@@ -1437,7 +1614,7 @@ namespace
     //*************************************************************************
     TEST(test_to_wstring)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
@@ -1452,7 +1629,7 @@ namespace
     //*************************************************************************
     TEST(test_to_u16string)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
@@ -1467,7 +1644,7 @@ namespace
     //*************************************************************************
     TEST(test_to_u32string)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
@@ -1568,16 +1745,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
       CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
       CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
@@ -1596,8 +1773,8 @@ namespace
       CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
       CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
 
-      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
-      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
     }
 
     //*************************************************************************
@@ -1608,16 +1785,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
@@ -1637,8 +1814,8 @@ namespace
       CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
 
       // The lines below should static assert.
-      //int8_t v1 = b.extract<int8_t, 26, 7>();
-      //int8_t v1 = b.extract<int8_t, 27, 6>();
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
     }
 
     //*************************************************************************
@@ -1726,34 +1903,34 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
-      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
-      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
-      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
-      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
-      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
-      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
-      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
-      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
-      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
-      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
-      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
-      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
-      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
-      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
-      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
-      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
-      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
-      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
-      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
-      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
-      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
-      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
-      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
-      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
 
-      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
-      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
 
     //*************************************************************************
@@ -1764,35 +1941,35 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
 
       // The lines below should static assert.
-      //int8_t v1 = b.extract<int8_t, 24, 9>();
-      //int8_t v2 = b.extract<int8_t, 25, 8>();
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
     }
 
     //*************************************************************************
@@ -1931,26 +2108,26 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
-      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
-      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
-      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
-      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
-      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
-      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
-      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
-      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
-      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
-      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
-      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
-      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
-      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
-      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
-      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
-      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
 
-      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
-      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
     }
 
     //*************************************************************************
@@ -1961,27 +2138,27 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
 
       // The lines below should static assert.
-      //int16_t v1 = b.extract<int16_t, 16, 17>());
-      //int16_t v2 = b.extract<int16_t, 17, 16>());
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>());
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>());
     }
   };
 }

From a7271e470a2ccaaedd6150b76f76e10b849e167d Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Thu, 4 Jan 2024 00:03:20 +0000
Subject: [PATCH 17/26] Work in progress

Comprehensive bitset type comparisons
---
 include/etl/private/bitset_new.h              | 1089 +++++---
 test/test_bitset_new_comparisons.cpp          |  239 ++
 test/test_bitset_new_default_element_type.cpp | 2243 +++++++----------
 ...itset_new_explicit_single_element_type.cpp |   20 +-
 ...st_bitset_new_ext_default_element_type.cpp | 1981 +++++----------
 ...t_new_ext_explicit_single_element_type.cpp |   16 +-
 test/vs2022/etl.vcxproj                       |    1 +
 test/vs2022/etl.vcxproj.filters               |    9 +-
 8 files changed, 2552 insertions(+), 3046 deletions(-)
 create mode 100644 test/test_bitset_new_comparisons.cpp

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 7a4a7fa1..1f76a448 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -46,6 +46,8 @@ SOFTWARE.
 #include "../span.h"
 #include "../string.h"
 #include "../enum_type.h"
+#include "../largest.h"
+#include "../smallest.h"
 
 #include <string.h>
 #include <stddef.h>
@@ -86,7 +88,7 @@ namespace etl
   /// or spread over an array of elements.
   ///\ingroup bitset
   //***************************************************************************
-  struct bitset_layout
+  struct bitset_storage_model
   {
     static ETL_CONSTANT char Undefined = 0;
     static ETL_CONSTANT char Single    = 1;
@@ -161,7 +163,7 @@ namespace etl
   ///\ingroup bitset
   //*************************************************************************
   template <typename TElement>
-  class bitset_impl<TElement, etl::bitset_layout::Single>
+  class bitset_impl<TElement, etl::bitset_storage_model::Single>
   {
   public:
 
@@ -180,9 +182,9 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 
     static 
-    void set(pointer      pbuffer,
-             size_t       /*number_of_elements*/,
-             element_type top_mask) ETL_NOEXCEPT
+    void set_all(pointer      pbuffer,
+                 size_t       /*number_of_elements*/,
+                 element_type top_mask) ETL_NOEXCEPT
     {
       *pbuffer = All_Set_Element & top_mask;
     }
@@ -192,10 +194,9 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14
     static
-    void set(pointer pbuffer, 
-             size_t  /*number_of_elements*/, 
-             size_t  position, 
-             bool    value = true)
+    void set_position(pointer pbuffer, 
+                      size_t  position, 
+                      bool    value = true)
     {
       const element_type mask = element_type(element_type(1) << position);
 
@@ -214,8 +215,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14
     static
-    void reset(pointer pbuffer, 
-               size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    void reset_all(pointer pbuffer, 
+                   size_t  /*number_of_elements*/) ETL_NOEXCEPT
     {
       *pbuffer = All_Clear_Element;
     }
@@ -225,9 +226,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14
     static
-    void reset(pointer pbuffer, 
-               size_t  /*number_of_elements*/, 
-               size_t  position)
+    void reset_position(pointer pbuffer, 
+                        size_t  position)
     {
       const element_type mask = element_type(element_type(1) << position);
       *pbuffer &= ~mask;
@@ -243,7 +243,7 @@ namespace etl
                      size_t      active_bits, 
                      const char* text) ETL_NOEXCEPT
     {
-      reset(pbuffer, 1U);
+      reset_all(pbuffer, 1U);
 
       if (text != ETL_NULLPTR)
       {
@@ -276,7 +276,7 @@ namespace etl
                      size_t         active_bits, 
                      const wchar_t* text) ETL_NOEXCEPT
     {
-      reset(pbuffer, 1U);
+      reset_all(pbuffer, 1U);
 
       if (text != ETL_NULLPTR)
       {
@@ -309,7 +309,7 @@ namespace etl
                      size_t          active_bits, 
                      const char16_t* text) ETL_NOEXCEPT
     {
-      reset(pbuffer, 1U);
+      reset_all(pbuffer, 1U);
 
       if (text != ETL_NULLPTR)
       {
@@ -342,7 +342,7 @@ namespace etl
                      size_t          active_bits, 
                      const char32_t* text) ETL_NOEXCEPT
     {
-      reset(pbuffer, 1U);
+      reset_all(pbuffer, 1U);
 
       if (text != ETL_NULLPTR)
       {
@@ -402,6 +402,29 @@ namespace etl
       return static_cast<T>(value);
     }
 
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+    ETL_CONSTEXPR14
+      static
+      T extract(const_pointer pbuffer)
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      const unsigned_t Mask = etl::make_lsb_mask<unsigned_t>(Length);
+      const unsigned_t Shift = Position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
+
+      if ((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, Length);
+      }
+
+      return static_cast<T>(value);
+    }
+
     //*************************************************************************
     /// Tests a bit at a position.
     /// Positions greater than the number of configured bits will return <b>false</b>.
@@ -409,7 +432,6 @@ namespace etl
     ETL_CONSTEXPR14 
     static 
     bool test(const_pointer pbuffer, 
-              size_t        /*number_of_elements*/, 
               size_t        position)
     {
       const element_type mask = element_type(element_type(1) << position);
@@ -503,8 +525,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 
     static 
-    void flip(pointer pbuffer, 
-              size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    void flip_all(pointer pbuffer, 
+                     size_t  /*number_of_elements*/) ETL_NOEXCEPT
     {
       *pbuffer = ~*pbuffer;
     }
@@ -515,7 +537,6 @@ namespace etl
     ETL_CONSTEXPR14 
     static 
     void flip_bits(pointer      pbuffer, 
-                   size_t       /*number_of_elements*/, 
                    element_type mask = etl::integral_limits<element_type>::max) ETL_NOEXCEPT
     {
       *pbuffer ^= mask;
@@ -526,57 +547,20 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 
     static 
-    void flip(pointer pbuffer, 
-              size_t  /*number_of_elements*/, 
-              size_t  position)
+    void flip_position(pointer pbuffer, 
+                       size_t  position)
     {
       const element_type mask = element_type(element_type(1) << position);
       *pbuffer ^= mask;
     }
 
-    //*************************************************************************
-    /// Read [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 
-    static 
-    bool read_bit(const_pointer pbuffer, 
-                  size_t        active_bits, 
-                  size_t        /*number_of_elements*/, 
-                  size_t        position) ETL_NOEXCEPT
-    {
-      if (position < active_bits)
-      {
-        const element_type mask = element_type(element_type(1) << position);
-        return (*pbuffer & mask) != 0U;
-      }
-
-      return false;
-    }
-
-    //*************************************************************************
-    /// Write [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 
-    static 
-    void write_bit(pointer pbuffer, 
-                   size_t  /*number_of_elements*/, 
-                   size_t  position) ETL_NOEXCEPT
-    {
-      return bit_reference(*this, position);
-    }
-
     //*************************************************************************
     /// Returns a string representing the bitset.
     //*************************************************************************
-#if ETL_USING_CPP11
-    template <typename TString = etl::string<Active_Bits>>
-#else
     template <typename TString>
-#endif
     ETL_CONSTEXPR14 
     static 
     TString to_string(const_pointer pbuffer,
-                      size_t /*number_of_elements*/,
                       size_t active_bits,
                       typename TString::value_type zero = typename TString::value_type('0'),
                       typename TString::value_type one  = typename TString::value_type('1'))
@@ -590,7 +574,7 @@ namespace etl
 
       for (size_t i = active_bits; i > 0; --i)
       {
-        result[active_bits - i] = test(pbuffer, 0, i - 1) ? one : zero;
+        result[active_bits - i] = test(pbuffer, i - 1) ? one : zero;
       }
 
       return result;
@@ -715,7 +699,7 @@ namespace etl
     {
       if (shift >= active_bits)
       {
-        reset(pbuffer, 1U);
+        reset_all(pbuffer, 1U);
       }
       else
       {
@@ -735,7 +719,7 @@ namespace etl
     {
       if (shift >= active_bits)
       {
-        reset(pbuffer, 1U);
+        reset_all(pbuffer, 1U);
       }
       else
       {
@@ -787,7 +771,7 @@ namespace etl
   ///\ingroup bitset
   //*************************************************************************
   template <typename TElement>
-  class bitset_impl<TElement, etl::bitset_layout::Multi>
+  class bitset_impl<TElement, etl::bitset_storage_model::Multi>
   {
   public:
 
@@ -810,79 +794,135 @@ namespace etl
       static ETL_CONSTANT bool value = ((Position + Length - 1) >> etl::log2<Bits_Per_Element>::value) == (Position >> etl::log2<Bits_Per_Element>::value);
     };
 
-    //*************************************************************************
-    /// Count the number of bits set.
-    //*************************************************************************
-    ETL_CONSTEXPR14 
-    static 
-    size_t count(const_pointer pbuffer, 
-                 size_t        number_of_elements) ETL_NOEXCEPT
-    {
-      size_t n = 0UL;
-
-      for (size_t i = 0UL; i < number_of_elements; ++i)
-      {
-        n += etl::count_bits(pbuffer[i]);
-      }
-
-      return n;
-    }
-
     //*************************************************************************
     /// Tests a bit at a position.
     /// Positions greater than the number of configured bits will return <b>false</b>.
     //*************************************************************************
     ETL_CONSTEXPR14 
     static
-    bool test(const_pointer pbuffer, 
-              size_t        number_of_elements, 
+    bool test(const_pointer pbuffer,
               size_t        position) ETL_NOEXCEPT
     {
-      size_t       index = 0U;
-      element_type mask  = element_type(0);
-
-      if (number_of_elements == 1U)
-      {
-        index = 0;
-        mask = element_type(1) << position;
-      }
-      else
-      {
-        index = position >> etl::log2<Bits_Per_Element>::value;
-        mask = element_type(1) << (position & (Bits_Per_Element - 1));
-      }
+      size_t index      = position >> etl::log2<Bits_Per_Element>::value;
+      element_type mask = element_type(1) << (position & (Bits_Per_Element - 1));
 
       return (pbuffer[index] & mask) != 0;
     }
 
+    //*************************************************************************
+    /// Count the number of bits set.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    size_t count(const_pointer pbuffer,
+                 size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      size_t count = 0;
+
+      while (number_of_elements-- != 0)
+      {
+        count += etl::count_bits(*pbuffer++);
+      }
+
+      return count;
+    }
+
+    //*************************************************************************
+    // Are all the bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    bool all(const_pointer pbuffer,
+             size_t        number_of_elements,
+             element_type  top_mask) ETL_NOEXCEPT
+    {
+      // All but the last.
+      while (number_of_elements-- != 1U)
+      {
+        if (*pbuffer++ != All_Set_Element)
+        {
+          return false;
+        }
+      }
+
+      // The last.
+      if ((*pbuffer & top_mask) != top_mask)
+      {
+        return false;
+      }
+
+      return true;
+    }
+
+    //*************************************************************************
+    /// Are none of the bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14
+      static
+      bool none(const_pointer pbuffer,
+                size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0)
+      {
+        if (*pbuffer++ != 0)
+        {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    //*************************************************************************
+    /// Are any of the bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    bool any(const_pointer pbuffer,
+             size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      bool any_set = false;
+
+      while (number_of_elements-- != 0)
+      {
+        if (*pbuffer++ != All_Clear_Element)
+        {
+          any_set = true;
+          break;
+        }
+      }
+
+      return any_set;
+    }
+
+    //*************************************************************************
+    /// Set all bits
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void set_all(pointer      pbuffer,
+                 size_t       number_of_elements,
+                 element_type top_mask) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 1U)
+      {
+        *pbuffer++ = All_Set_Element;
+      }
+
+      *pbuffer = (All_Set_Element & top_mask);
+    }
 
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
     ETL_CONSTEXPR14
     static
-    void set(pointer pbuffer, 
-             size_t  number_of_elements, 
-             size_t  position, 
-             bool    value = true) ETL_NOEXCEPT
+    void set_position(pointer pbuffer, 
+                      size_t  position, 
+                      bool    value = true) ETL_NOEXCEPT
     {
-      size_t    index = 0;
-      element_type bit = 0;
-
-      if (number_of_elements == 0) ETL_UNLIKELY
-      {
-        return;
-      }
-      else if (number_of_elements == 1U)
-      {
-        index = 0;
-        bit = element_type(1) << position;
-      }
-      else
-      {
-        index = position >> etl::log2<Bits_Per_Element>::value;
-        bit = element_type(1) << (position & (Bits_Per_Element - 1));
-      }
+      size_t       index = position >> etl::log2<Bits_Per_Element>::value;
+      element_type bit   = element_type(1) << (position & (Bits_Per_Element - 1));
 
       if (value)
       {
@@ -924,7 +964,7 @@ namespace etl
 
         while (i > 0)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STR('1'));
+          set_position(pbuffer, --i, *text++ == ETL_STR('1'));
         }
       }
     }
@@ -959,7 +999,7 @@ namespace etl
 
         while (i > 0)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STRL('1'));
+          set_position(pbuffer, --i, *text++ == ETL_STRL('1'));
         }
       }
     }
@@ -994,7 +1034,7 @@ namespace etl
 
         while (i > 0)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STRu('1'));
+          set_position(pbuffer, --i, *text++ == ETL_STRu('1'));
         }
       }
     }
@@ -1029,70 +1069,18 @@ namespace etl
 
         while (i > 0)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STRU('1'));
+          set_position(pbuffer, --i, *text++ == ETL_STRU('1'));
         }
       }
     }
 
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 
-    static 
-    void set(pointer     pbuffer, 
-             size_t      number_of_elements, 
-             size_t      total_bits, 
-             const char* text) ETL_NOEXCEPT
-    {
-      from_string(pbuffer, number_of_elements, total_bits, text);
-    }
-
-    //*************************************************************************
-    /// Set from a wstring.
-    //*************************************************************************
-    ETL_CONSTEXPR14
-    static
-    void set(pointer        pbuffer, 
-             size_t         number_of_elements, 
-             size_t         total_bits, 
-             const wchar_t* text) ETL_NOEXCEPT
-    {
-      from_string(pbuffer, number_of_elements, total_bits, text);
-    }
-
-    //*************************************************************************
-    /// Set from a u16string.
-    //*************************************************************************
-    ETL_CONSTEXPR14
-    static
-    void set(pointer         pbuffer, 
-             size_t          number_of_elements, 
-             size_t          total_bits, 
-             const char16_t* text) ETL_NOEXCEPT
-    {
-      from_string(pbuffer, number_of_elements, total_bits, text);
-    }
-
-    //*************************************************************************
-    /// Set from a u32string.
-    //*************************************************************************
-    ETL_CONSTEXPR14
-    static
-    void set(pointer         pbuffer, 
-             size_t          number_of_elements, 
-             size_t          total_bits, 
-             const char32_t* text) ETL_NOEXCEPT
-    {
-      from_string(pbuffer, number_of_elements, total_bits, text);
-    }
-
     //*************************************************************************
     /// Reset all of the bits.
     //*************************************************************************
     ETL_CONSTEXPR14
     static
-    void reset(pointer pbuffer, 
-               size_t  number_of_elements) ETL_NOEXCEPT
+    void reset_all(pointer pbuffer,
+                   size_t  number_of_elements) ETL_NOEXCEPT
     {
       while (number_of_elements-- != 0U)
       {
@@ -1105,9 +1093,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14
     static
-    void reset(pointer pbuffer, 
-               size_t  number_of_elements, 
-               size_t  position) ETL_NOEXCEPT
+    void reset_position(pointer pbuffer, 
+                        size_t  position) ETL_NOEXCEPT
     {
       const size_t       index = position >> etl::log2<Bits_Per_Element>::value;;
       const element_type bit = element_type(1) << (position & (Bits_Per_Element - 1));
@@ -1195,6 +1182,7 @@ namespace etl
 
     //*************************************************************************
     /// Extract an integral value from an arbitary position and length.
+    /// Run time position and length.
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
@@ -1234,6 +1222,7 @@ namespace etl
 
     //*************************************************************************
     /// Extract an integral value when the value fits in one element.
+    /// Compile time position and length.
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
@@ -1252,6 +1241,7 @@ namespace etl
 
     //*************************************************************************
     /// Extract an integral value when the value spans more than one element.
+    /// Compile time position and length.
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
@@ -1259,18 +1249,55 @@ namespace etl
     typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
       extract_from_buffer(const_pointer pbuffer)
     {      
+      // Start with index of the element containing the msb.
       const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
 
-      // Start with index of the element containing the msb.
-      int element_index = Msb_Element_Index;
-
-      // The value is spread over multiple elements.       
-      size_t length = Length;
-
       // Get the number of active bits in the first element 
-      size_t active_bits_in_msb = ((Position + Length - 1) % Bits_Per_Element) + 1;
+      const size_t Active_Bits_In_Msb = ((Position + Length - 1) % Bits_Per_Element) + 1;
 
-      return extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
+      return extract_from_multiple_elements<T>(pbuffer, Msb_Element_Index, Active_Bits_In_Msb, Length);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    static
+    T extract(const_pointer pbuffer,
+              size_t        position,
+              size_t        length = etl::integral_limits<T>::bits)
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = extract_from_buffer<unsigned_t>(pbuffer, position, length);
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length>
+    ETL_CONSTEXPR14
+    static
+    T extract(const_pointer pbuffer)
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = extract_from_buffer<unsigned_t, Position, Length>(pbuffer);
+
+      if ((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, Length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
@@ -1278,8 +1305,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14
     static
-    void flip(pointer pbuffer, 
-              size_t  number_of_elements) ETL_NOEXCEPT
+    void flip_all(pointer pbuffer, 
+                     size_t  number_of_elements) ETL_NOEXCEPT
     {
       operator_not(pbuffer, number_of_elements);
     }
@@ -1289,9 +1316,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14
     static
-    void flip(pointer pbuffer, 
-              size_t  number_of_elements, 
-              size_t  position) ETL_NOEXCEPT
+    void flip_position(pointer pbuffer, 
+                       size_t  position) ETL_NOEXCEPT
     {
       const size_t       index = position >> etl::log2<Bits_Per_Element>::value;;
       const element_type bit   = element_type(1) << (position & (Bits_Per_Element - 1));
@@ -1299,52 +1325,6 @@ namespace etl
       pbuffer[index] ^= bit;
     }
 
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14
-    static
-    bool all(const_pointer pbuffer, 
-             size_t        number_of_elements, 
-             element_type  top_mask) ETL_NOEXCEPT
-    {
-      // All but the last.
-      for (size_t i = 0UL; i < (number_of_elements - 1U); ++i)
-      {
-        if (pbuffer[i] != All_Set_Element)
-        {
-          return false;
-        }
-      }
-
-      // The last.
-      if (pbuffer[number_of_elements - 1U] != (All_Set_Element & top_mask))
-      {
-        return false;
-      }
-
-      return true;
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14
-    static
-    bool none(const_pointer pbuffer, 
-              size_t        number_of_elements) ETL_NOEXCEPT
-    {
-      for (size_t i = 0UL; i < number_of_elements; ++i)
-      {
-        if (pbuffer[i] != 0)
-        {
-          return false;
-        }
-      }
-
-      return true;
-    }
-
     //*************************************************************************
     /// Finds the next bit in the specified state.
     ///\param state    The state to search for.
@@ -1411,7 +1391,6 @@ namespace etl
     ETL_CONSTEXPR14
     static
     TString to_string(const_pointer                pbuffer,
-                      size_t                       number_of_elements, 
                       size_t                       active_bits, 
                       typename TString::value_type zero, 
                       typename TString::value_type one)
@@ -1425,7 +1404,7 @@ namespace etl
 
       for (size_t i = active_bits; i > 0; --i)
       {
-        result[active_bits - i] = test(pbuffer, number_of_elements, i - 1) ? one : zero;
+        result[active_bits - i] = test(pbuffer, i - 1) ? one : zero;
       }
 
       return result;
@@ -1440,9 +1419,11 @@ namespace etl
                              const_pointer rhs_pbuffer, 
                              size_t        number_of_elements) ETL_NOEXCEPT
     {
-      while (number_of_elements != 0)
+      while (number_of_elements-- != 0)
       {
-        *lhs_pbuffer++ = *rhs_pbuffer++;
+        *lhs_pbuffer = *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
       }
     }
 
@@ -1457,7 +1438,9 @@ namespace etl
     {
       while (number_of_elements-- != 0)
       {
-        *lhs_pbuffer++ &= *rhs_pbuffer++;
+        *lhs_pbuffer &= *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
       }
     }
 
@@ -1472,7 +1455,9 @@ namespace etl
     {
       while (number_of_elements-- != 0)
       {
-        *lhs_pbuffer++ != *rhs_pbuffer++;
+        *lhs_pbuffer |= *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
       }
     }
 
@@ -1487,7 +1472,9 @@ namespace etl
     {
       while (number_of_elements-- != 0)
       {
-        *lhs_pbuffer++ ^= *rhs_pbuffer++;
+        *lhs_pbuffer ^= *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
       }
     }
 
@@ -1501,7 +1488,8 @@ namespace etl
     {
       while (number_of_elements-- != 0)
       {
-        *pbuffer++ = ~*pbuffer++;
+        *pbuffer = ~*pbuffer;
+        ++pbuffer;
       }
     }
 
@@ -1515,50 +1503,57 @@ namespace etl
                              size_t  active_bits, 
                              size_t  shift) ETL_NOEXCEPT
     {
-      // The place where the elements are split when shifting.
-      const size_t split_position = Bits_Per_Element - (shift % Bits_Per_Element);
-
-      // Where we are shifting from.
-      int src_index = int(number_of_elements - (shift / Bits_Per_Element) - 1U);
-
-      // Where we are shifting to.
-      int dst_index = int(number_of_elements - 1U);
-
-      // Shift control constants.
-      const size_t lsb_shift = Bits_Per_Element - split_position;
-      const size_t msb_shift = split_position;
-
-      const element_type lsb_mask = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
-      const element_type msb_mask = etl::integral_limits<element_type>::max - lsb_mask;
-      const element_type lsb_shifted_mask = element_type(lsb_mask << lsb_shift);
-
-      // First lsb.
-      element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
-      pbuffer[dst_index] = lsb;
-      --src_index;
-
-      // Now do the shifting.
-      while (src_index >= 0)
+      if (shift >= active_bits)
       {
-        // Shift msb.
-        element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
-        pbuffer[dst_index] = pbuffer[dst_index] | msb;
-        --dst_index;
+        reset_all(pbuffer, number_of_elements);
+      }
+      else
+      {
+        // The place where the elements are split when shifting.
+        const size_t split_position = Bits_Per_Element - (shift % Bits_Per_Element);
 
-        // Shift lsb.
+        // Where we are shifting from.
+        int src_index = int(number_of_elements - (shift / Bits_Per_Element) - 1U);
+
+        // Where we are shifting to.
+        int dst_index = int(number_of_elements - 1U);
+
+        // Shift control constants.
+        const size_t lsb_shift = Bits_Per_Element - split_position;
+        const size_t msb_shift = split_position;
+
+        const element_type lsb_mask = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
+        const element_type msb_mask = etl::integral_limits<element_type>::max - lsb_mask;
+        const element_type lsb_shifted_mask = element_type(lsb_mask << lsb_shift);
+
+        // First lsb.
         element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
         pbuffer[dst_index] = lsb;
         --src_index;
-      }
 
-      // Clear the remaining bits.
-      // First lsb.
-      pbuffer[dst_index] &= lsb_shifted_mask;
+        // Now do the shifting.
+        while (src_index >= 0)
+        {
+          // Shift msb.
+          element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
+          pbuffer[dst_index] = pbuffer[dst_index] | msb;
+          --dst_index;
 
-      // The other remaining bytes on the right.
-      for (int i = 0; i < dst_index; ++i)
-      {
-        pbuffer[i] = 0;
+          // Shift lsb.
+          element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
+          pbuffer[dst_index] = lsb;
+          --src_index;
+        }
+
+        // Clear the remaining bits.
+        // First lsb.
+        pbuffer[dst_index] &= lsb_shifted_mask;
+
+        // The other remaining bytes on the right.
+        for (int i = 0; i < dst_index; ++i)
+        {
+          pbuffer[i] = 0;
+        }
       }
     }
 
@@ -1572,52 +1567,59 @@ namespace etl
                               size_t  active_bits, 
                               size_t  shift) ETL_NOEXCEPT
     {
-      // The place where the elements are split when shifting.
-      const size_t split_position = shift % Bits_Per_Element;
-
-      // Where we are shifting from.
-      int src_index = int(shift / Bits_Per_Element);
-
-      // Where we are shifting to.
-      int dst_index = 0;
-
-      // Shift control constants.
-      const size_t lsb_shift = Bits_Per_Element - split_position;
-      const size_t msb_shift = split_position;
-
-      const element_type lsb_mask = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
-      const element_type msb_mask = etl::integral_limits<element_type>::max - lsb_mask;
-      const element_type msb_shifted_mask = element_type(msb_mask >> msb_shift);
-
-      // Now do the shifting.
-      while (src_index < int(number_of_elements - 1))
+      if (shift >= active_bits)
       {
-        // Shift msb.
-        element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
-        ++src_index;
-
-        // Shift lsb.
-        element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
-
-        // Combine them.
-        pbuffer[dst_index] = lsb | msb;
-        ++dst_index;
+        reset_all(pbuffer, number_of_elements);
       }
-
-      // Final msb.
-      element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
-      pbuffer[dst_index] = msb;
-
-      // Clear the remaining bits.
-      // First msb.
-      pbuffer[dst_index] &= msb_shifted_mask;
-      ++dst_index;
-
-      // The other remaining bytes.
-      while (dst_index < int(number_of_elements))
+      else
       {
-        pbuffer[dst_index] = 0;
+        // The place where the elements are split when shifting.
+        const size_t split_position = shift % Bits_Per_Element;
+
+        // Where we are shifting from.
+        int src_index = int(shift / Bits_Per_Element);
+
+        // Where we are shifting to.
+        int dst_index = 0;
+
+        // Shift control constants.
+        const size_t lsb_shift = Bits_Per_Element - split_position;
+        const size_t msb_shift = split_position;
+
+        const element_type lsb_mask = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
+        const element_type msb_mask = etl::integral_limits<element_type>::max - lsb_mask;
+        const element_type msb_shifted_mask = element_type(msb_mask >> msb_shift);
+
+        // Now do the shifting.
+        while (src_index < int(number_of_elements - 1))
+        {
+          // Shift msb.
+          element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
+          ++src_index;
+
+          // Shift lsb.
+          element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
+
+          // Combine them.
+          pbuffer[dst_index] = lsb | msb;
+          ++dst_index;
+        }
+
+        // Final msb.
+        element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
+        pbuffer[dst_index] = msb;
+
+        // Clear the remaining bits.
+        // First msb.
+        pbuffer[dst_index] &= msb_shifted_mask;
         ++dst_index;
+
+        // The other remaining bytes.
+        while (dst_index < int(number_of_elements))
+        {
+          pbuffer[dst_index] = 0;
+          ++dst_index;
+        }
       }
     }
 
@@ -1697,7 +1699,8 @@ namespace etl
     static ETL_CONSTANT size_t       Allocated_Bits     = 0U;
     static ETL_CONSTANT element_type All_Set_Element    = 0U;
     static ETL_CONSTANT element_type All_Clear_Element  = 0U;
-    static ETL_CONSTANT char         Element_Layout     = etl::bitset_layout::Undefined;
+    static ETL_CONSTANT size_t       Size               = 0U;
+    static ETL_CONSTANT char         Storage_Model      = etl::bitset_storage_model::Undefined;
 
     static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
   };
@@ -1723,7 +1726,8 @@ namespace etl
     static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
     static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
     static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-    static ETL_CONSTANT char         Element_Layout     = (Number_Of_Elements == 1U) ? etl::bitset_layout::Single : etl::bitset_layout::Multi;
+    static ETL_CONSTANT size_t       Size               = Active_Bits;
+    static ETL_CONSTANT char         Storage_Model      = (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
 
   private:
     
@@ -1828,7 +1832,7 @@ namespace etl
     ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT
       : buffer()
     {
-      implementation::reset(buffer, Number_Of_Elements);
+      implementation::reset_all(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -1900,7 +1904,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set() ETL_NOEXCEPT
     {
-      implementation::set(buffer, Number_Of_Elements, Top_Mask);
+      implementation::set_all(buffer, Number_Of_Elements, Top_Mask);
 
       return *this;
     }
@@ -1912,7 +1916,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      implementation::set(buffer, Number_Of_Elements, position, value);
+      implementation::set_position(buffer, position, value);
       
       return *this;
     }
@@ -2013,6 +2017,7 @@ namespace etl
 
     //*************************************************************************
     /// Extract an integral value from an arbitary position and length.
+    /// Run time position and length.
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
@@ -2023,11 +2028,12 @@ namespace etl
       ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
 
-      return implementation::extract<T>(buffer, position, length);
+      return implementation::template extract<T>(buffer, position, length);
     }
 
     //*************************************************************************
     /// Extract an integral value from an arbitary position and length.
+    /// Compile time position and length.
     //*************************************************************************
     template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
     ETL_CONSTEXPR14
@@ -2037,7 +2043,7 @@ namespace etl
       ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
 
-      return implementation::extract<T>(buffer, Position, Length);
+      return implementation::template extract<T, Position, Length>(buffer);
     }
 
     //*************************************************************************
@@ -2065,7 +2071,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& reset() ETL_NOEXCEPT
     {
-      implementation::reset(buffer, Number_Of_Elements);
+      implementation::reset_all(buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2077,7 +2083,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      implementation::reset(buffer, Number_Of_Elements, position);
+      implementation::reset_position(buffer, position);
 
       return *this;
     }
@@ -2090,7 +2096,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
 
-      return implementation::test(buffer, Number_Of_Elements, position);
+      return implementation::test(buffer, position);
     }
  
     //*************************************************************************
@@ -2122,6 +2128,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
     {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
       return implementation::all(buffer, Number_Of_Elements, Top_Mask, mask);
     }
 
@@ -2138,6 +2146,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
     {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
       return implementation::none(buffer, Number_Of_Elements, mask);
     }
 
@@ -2154,6 +2164,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
     {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
       return implementation::any(buffer, Number_Of_Elements, mask);
     }
 
@@ -2162,7 +2174,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& flip() ETL_NOEXCEPT
     {
-      implementation::flip(buffer, Number_Of_Elements);
+      implementation::flip_all(buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2174,7 +2186,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      implementation::flip(buffer, Number_Of_Elements, position);
+      implementation::flip_position(buffer, position);
 
       return *this;
     }
@@ -2184,7 +2196,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
     {
-      return implementation::test(buffer, Number_Of_Elements, position);
+      return implementation::test(buffer, position);
     }
 
     //*************************************************************************
@@ -2206,7 +2218,7 @@ namespace etl
     ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
                                       typename TString::value_type one  = typename TString::value_type('1')) const
     {
-      return implementation::template to_string<TString>(buffer, Number_Of_Elements, Active_Bits, zero, one);
+      return implementation::template to_string<TString>(buffer, Active_Bits, zero, one);
     }
 
     //*************************************************************************
@@ -2303,7 +2315,7 @@ namespace etl
     {
       etl::bitset<Active_Bits, TElement> temp(*this);
 
-      implementation::flip(temp.buffer, Number_Of_Elements);
+      implementation::flip_all(temp.buffer, Number_Of_Elements);
 
       return temp;
     }
@@ -2327,7 +2339,7 @@ namespace etl
     {
       if (shift >= Active_Bits)
       {
-        implementation::reset(buffer, Number_Of_Elements);
+        implementation::reset_all(buffer, Number_Of_Elements);
       }
       else
       {
@@ -2356,7 +2368,7 @@ namespace etl
     {
       if (shift >= Active_Bits)
       {
-        implementation::reset(buffer, Number_Of_Elements);
+        implementation::reset_all(buffer, Number_Of_Elements);
       }
       else
       {
@@ -2374,6 +2386,14 @@ namespace etl
       return implementation::operator_equality(lhs.buffer, rhs.buffer, lhs.Number_Of_Elements);
     }
 
+    //*************************************************************************
+    /// operator !=
+    //*************************************************************************
+    friend ETL_CONSTEXPR14 bool operator !=(const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+    {
+      return !(lhs == rhs);
+    }
+
     //*************************************************************************
     /// swap
     //*************************************************************************
@@ -2405,13 +2425,13 @@ namespace etl
     //*************************************************************************
     /// Correct the unused top bits after bit manipulation.
     //*************************************************************************
-    ETL_CONSTEXPR14 static void clear_unused_bits_in_msb(pointer pbuffer) ETL_NOEXCEPT
-    {
-      buffer[Number_Of_Elements - 1U] &= Top_Mask;
-    }
+    //ETL_CONSTEXPR14 static void clear_unused_bits_in_msb(pointer pbuffer) ETL_NOEXCEPT
+    //{
+    //  pbuffer[Number_Of_Elements - 1U] &= Top_Mask;
+    //}
 
     // The implementation of the bitset functionality.
-    typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_layout::Single : etl::bitset_layout::Multi> implementation;
+    typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi> implementation;
 
     // The storage for the bitset.
     element_type buffer[Number_Of_Elements];
@@ -2452,16 +2472,16 @@ namespace etl
     temp ^= rhs;
     return temp;
   }
+}
 
-  //***************************************************************************
-  /// operator !=
-  ///\ingroup bitset
-  //***************************************************************************
-  template<size_t Active_Bits, typename TElement>
-  ETL_CONSTEXPR14 bool operator != (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
-  {
-    return !(lhs == rhs);
-  }
+//***************************************************************************
+/// operator !=
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 bool operator != (const etl::bitset<Active_Bits, TElement>& lhs, const etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
 }
 
 //*************************************************************************
@@ -2501,7 +2521,8 @@ namespace etl
     static ETL_CONSTANT size_t       Allocated_Bits     = 0U;
     static ETL_CONSTANT element_type All_Set_Element    = 0U;
     static ETL_CONSTANT element_type All_Clear_Element  = 0U;
-    static ETL_CONSTANT char         Element_Layout     = etl::bitset_layout::Undefined;
+    static ETL_CONSTANT size_t       Size               = 0U;
+    static ETL_CONSTANT char         Storage_Model      = etl::bitset_storage_model::Undefined;
 
     static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
   };
@@ -2527,7 +2548,8 @@ namespace etl
     static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
     static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
     static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-    static ETL_CONSTANT char         Element_Layout     = (Number_Of_Elements == 1U) ? etl::bitset_layout::Single : etl::bitset_layout::Multi;
+    static ETL_CONSTANT size_t       Size               = Active_Bits;
+    static ETL_CONSTANT char         Storage_Model      = (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
 
   private:
 
@@ -2634,7 +2656,7 @@ namespace etl
       : pbuffer(pbuffer_)
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      implementation::reset(pbuffer, Number_Of_Elements);
+      implementation::reset_all(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2644,7 +2666,7 @@ namespace etl
       : pbuffer(buffer.data())
     {
       ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
-      implementation::reset(pbuffer, Number_Of_Elements);
+      implementation::reset_all(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2781,7 +2803,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set() ETL_NOEXCEPT
     {
-      implementation::set(pbuffer, Number_Of_Elements, Top_Mask);
+      implementation::set_all(pbuffer, Number_Of_Elements, Top_Mask);
 
       return *this;
     }
@@ -2793,7 +2815,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
       
-      implementation::set(pbuffer, Number_Of_Elements, position, value);
+      implementation::set_position(pbuffer, position, value);
 
       return *this;
     }
@@ -2893,6 +2915,7 @@ namespace etl
 
     //*************************************************************************
     /// Extract an integral value from an arbitary position and length.
+    /// Run time position and length.
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
@@ -2903,21 +2926,22 @@ namespace etl
       ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
       ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
 
-      return implementation::extract<T>(pbuffer, position, length);
+      return implementation::template extract<T>(pbuffer, position, length);
     }
 
     //*************************************************************************
     /// Extract an integral value from an arbitary position and length.
+    /// Compile time position and length.
     //*************************************************************************
     template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
     ETL_CONSTEXPR14
-      T extract() const
+    T extract() const
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value,              "Only integral types are supported");
       ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
       ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
 
-      return implementation::extract<T>(pbuffer, Position, Length);
+      return implementation::template extract<T, Position, Length>(pbuffer);
     }
 
     //*************************************************************************
@@ -2945,7 +2969,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& reset() ETL_NOEXCEPT
     {
-      implementation::reset(pbuffer, Number_Of_Elements);
+      implementation::reset_all(pbuffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2957,7 +2981,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      implementation::reset(pbuffer, Number_Of_Elements, position);
+      implementation::reset_position(pbuffer, position);
 
       return *this;
     }
@@ -2970,7 +2994,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
       
-      return implementation::test(pbuffer, Number_Of_Elements, position);
+      return implementation::test(pbuffer, position);
     }
 
     //*************************************************************************
@@ -3002,6 +3026,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
     {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
       return implementation::all(pbuffer, Number_Of_Elements, Top_Mask, mask);
     }
 
@@ -3018,6 +3044,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
     {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
       return implementation::none(pbuffer, Number_Of_Elements, mask);
     }
 
@@ -3034,6 +3062,8 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
     {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
       return implementation::any(pbuffer, Number_Of_Elements, mask);
     }
 
@@ -3042,7 +3072,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& flip() ETL_NOEXCEPT
     {
-      implementation::flip(pbuffer, Number_Of_Elements);
+      implementation::flip_all(pbuffer, Number_Of_Elements);
 
       return *this;
     }
@@ -3054,7 +3084,7 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
       
-      implementation::flip(pbuffer, Number_Of_Elements, position);
+      implementation::flip_position(pbuffer, position);
 
       return *this;
     }
@@ -3064,7 +3094,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
     {
-      return implementation::test(pbuffer, Number_Of_Elements, position);
+      return implementation::test(pbuffer, position);
     }
 
     //*************************************************************************
@@ -3084,9 +3114,9 @@ namespace etl
     template <typename TString>
 #endif
     ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
-      typename TString::value_type one = typename TString::value_type('1')) const
+                                      typename TString::value_type one  = typename TString::value_type('1')) const
     {
-      return implementation::template to_string<TString>(pbuffer, Number_Of_Elements, Active_Bits, zero, one);
+      return implementation::template to_string<TString>(pbuffer, Active_Bits, zero, one);
     }
 
     //*************************************************************************
@@ -3168,6 +3198,14 @@ namespace etl
       return implementation::operator_equality(lhs.pbuffer, rhs.pbuffer, lhs.Number_Of_Elements);
     }
 
+    //*************************************************************************
+    /// operator !=
+    //*************************************************************************
+    friend ETL_CONSTEXPR14 bool operator !=(const bitset_ext<Active_Bits, TElement>& lhs, const bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+    {
+      return !(lhs == rhs);
+    }
+
     //*************************************************************************
     /// swap
     //*************************************************************************
@@ -3196,30 +3234,30 @@ namespace etl
 
   private:
 
-    //*************************************************************************
-    /// Correct the unused top bits after bit manipulation.
-    //*************************************************************************
-    ETL_CONSTEXPR14 static void clear_unused_bits_in_msb() ETL_NOEXCEPT
-    {
-      pbuffer[Number_Of_Elements - 1U] &= Top_Mask;
-    }
+    ////*************************************************************************
+    ///// Correct the unused top bits after bit manipulation.
+    ////*************************************************************************
+    //ETL_CONSTEXPR14 static void clear_unused_bits_in_msb() ETL_NOEXCEPT
+    //{
+    //  pbuffer[Number_Of_Elements - 1U] &= Top_Mask;
+    //}
 
     // The implementation of the bitset functionality.
-    typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_layout::Single : etl::bitset_layout::Multi> implementation;
+    typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi> implementation;
 
     // Pointer to the storage for the bitset.
     element_type* pbuffer;
   };
+}
 
-  //***************************************************************************
-  /// operator !=
-  ///\ingroup bitset
-  //***************************************************************************
-  template<size_t Active_Bits, typename TElement>
-  ETL_CONSTEXPR14 bool operator != (const bitset_ext<Active_Bits, TElement>& lhs, const bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
-  {
-    return !(lhs == rhs);
-  }
+//***************************************************************************
+/// operator !=
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 bool operator != (const etl::bitset_ext<Active_Bits, TElement>& lhs, const etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
 }
 
 //*************************************************************************
@@ -3231,6 +3269,275 @@ ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement>& lhs, etl::bits
   lhs.swap(rhs);
 }
 
+namespace etl
+{
+  namespace private_bitset
+  {
+    //*************************************************************************
+    /// Compare bitset spans.
+    /// Assumes that the lhs span's element type is larger than rhs's.
+    //*************************************************************************
+    template <typename TLhsSpan, typename TRhsSpan>
+    bool compare_bitset_spans(const TLhsSpan& lhs_span, const TRhsSpan& rhs_span)
+    {
+      typedef typename TLhsSpan::value_type lhs_element_t;
+      typedef typename TRhsSpan::value_type rhs_element_t;
+
+      const int steps = static_cast<int>(sizeof(lhs_element_t) / sizeof(rhs_element_t));
+
+      typename TLhsSpan::iterator lhs_itr = lhs_span.begin();
+      typename TRhsSpan::iterator rhs_itr = rhs_span.begin();
+
+      while (lhs_itr != lhs_span.end())
+      {
+        const lhs_element_t& lhs_value = *lhs_itr;
+
+        // Build the rhs element in terms of the lhs element type.
+        lhs_element_t rhs_value = 0;
+
+        const int shift_step = etl::integral_limits<rhs_element_t>::bits;
+        int shift = 0;
+
+        for (int i = 0; i < steps; ++i)
+        {
+          rhs_value |= (static_cast<lhs_element_t>(*rhs_itr) << shift);
+          ++rhs_itr;
+          shift += shift_step;
+        }
+
+        if (lhs_value != rhs_value)
+        {
+          return false;
+        }
+
+        ++lhs_itr;
+      }
+
+      return true;
+    }
+  }
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset 
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator == (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset<Active_Bits, TLhsElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset<Active_Bits, TRhsElement>::const_span_type rhs_span = rhs.span();
+
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset 
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset_ext
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator == (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset_ext<Active_Bits, TLhsElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset_ext<Active_Bits, TRhsElement>::const_span_type rhs_span = rhs.span();
+
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset_ext
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset compared with bitset_ext, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator == (const etl::bitset<Active_Bits, TElement>& lhs, const etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  const char   Storage_Model      = etl::bitset<Active_Bits, TElement>::Storage_Model;
+  const size_t Number_Of_Elements = etl::bitset<Active_Bits, TElement>::Number_Of_Elements;
+
+  typename etl::bitset<Active_Bits, TElement>::const_span_type     lhs_span = lhs.span();
+  typename etl::bitset_ext<Active_Bits, TElement>::const_span_type rhs_span = rhs.span();
+
+  typedef etl::bitset_impl<TElement, Storage_Model> implementation;
+
+  return implementation::operator_equality(lhs_span.begin(), rhs_span.begin(), Number_Of_Elements);
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset compared with bitset_ext, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator != (const etl::bitset<Active_Bits, TElement>& lhs, const etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset_ext compared with bitset, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator == (const etl::bitset_ext<Active_Bits, TElement>& lhs, const etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  const char   Storage_Model      = etl::bitset<Active_Bits, TElement>::Storage_Model;
+  const size_t Number_Of_Elements = etl::bitset<Active_Bits, TElement>::Number_Of_Elements;
+
+  typename etl::bitset_ext<Active_Bits, TElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset<Active_Bits, TElement>::const_span_type     rhs_span = rhs.span();
+
+  typedef etl::bitset_impl<TElement, Storage_Model> implementation;
+
+  return implementation::operator_equality(lhs_span.begin(), rhs_span.begin(), Number_Of_Elements);
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset_ext compared with bitset, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator != (const etl::bitset_ext<Active_Bits, TElement>& lhs, const etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset compared with bitset_ext, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+operator == (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset<Active_Bits, TLhsElement>::const_span_type     lhs_span = lhs.span();
+  typename etl::bitset_ext<Active_Bits, TRhsElement>::const_span_type rhs_span = rhs.span();
+
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset compared with bitset_ext, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset_ext compared with bitset, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator == (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset_ext<Active_Bits, TLhsElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset<Active_Bits, TRhsElement>::const_span_type     rhs_span = rhs.span();
+
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset_ext compared with bitset, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
 #include "minmax_pop.h"
 
 #endif
diff --git a/test/test_bitset_new_comparisons.cpp b/test/test_bitset_new_comparisons.cpp
new file mode 100644
index 00000000..4436982f
--- /dev/null
+++ b/test/test_bitset_new_comparisons.cpp
@@ -0,0 +1,239 @@
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2022 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#include "unit_test_framework.h"
+
+#include "etl/private/bitset_new.h"
+
+namespace
+{
+  using ull = unsigned long long;
+
+  SUITE(test_bitset_new_comparisons)
+  {
+    //*************************************************************************
+    TEST(test_equality_single_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x0123456789012345ULL);
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data3(0x0123456789012345ULL, buffer3);
+      etl::bitset_ext<64, uint64_t> data4(0x0123456789012345ULL, buffer4);
+
+      // Double check we are using the single element storage model.
+      CHECK(etl::bitset_storage_model::Single == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data4.Storage_Model);
+
+      CHECK(data1 == data2); // bitset     == bitset
+      CHECK(data1 == data3); // bitset     == bitset_ext
+      CHECK(data3 == data1); // bitset_ext == bitset
+      CHECK(data3 == data4); // bitset_ext == bitset_ext
+    }
+
+    //*************************************************************************
+    TEST(test_inequality_single_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x0123456784012345ULL);
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data3(0x0123456787012345ULL, buffer3);
+      etl::bitset_ext<64, uint64_t> data4(0x0123426789012345ULL, buffer4);
+
+      // Double check we are using the single element storage model.
+      CHECK(etl::bitset_storage_model::Single == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data4.Storage_Model);
+
+      CHECK(data1 != data2); // bitset     != bitset
+      CHECK(data1 != data3); // bitset     != bitset_ext
+      CHECK(data3 != data1); // bitset_ext != bitset
+      CHECK(data3 != data4); // bitset_ext != bitset_ext
+    }
+
+    //*************************************************************************
+    TEST(test_equality_multi_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456789012345ULL);
+
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64> data3(0x0123456789012345ULL, buffer3);
+      etl::bitset_ext<64> data4(0x0123456789012345ULL, buffer4);
+
+      // Double check we are using the multi element storage model.
+      CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model);
+
+      CHECK(data1 == data2); // bitset     == bitset
+      CHECK(data1 == data3); // bitset     == bitset_ext
+      CHECK(data3 == data1); // bitset_ext == bitset
+      CHECK(data3 == data4); // bitset_ext == bitset_ext
+    }
+
+    //*************************************************************************
+    TEST(test_inequality_multi_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456784012345ULL);
+
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64> data3(0x0123456787012345ULL, buffer3);
+      etl::bitset_ext<64> data4(0x0123426789012345ULL, buffer4);
+
+      // Double check we are using the multi element storage model.
+      CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model);
+
+      CHECK(data1 != data2); // bitset     != bitset
+      CHECK(data1 != data3); // bitset     != bitset_ext
+      CHECK(data3 != data1); // bitset_ext != bitset
+      CHECK(data3 != data4); // bitset_ext != bitset_ext
+    }
+
+    //*************************************************************************
+    TEST(test_equality_mixed_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456789012345ULL);
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data3(0x0123456789012345ULL, buffer3);
+      etl::bitset_ext<64> data4(0x0123456789012345ULL, buffer4);
+
+      // Double check we are using the single/multi element storage model.
+      CHECK(etl::bitset_storage_model::Single == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi  == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi  == data4.Storage_Model);
+
+      CHECK(data1 == data2); // bitset     (S) == bitset     (M)
+      CHECK(data2 == data1); // bitset     (M) == bitset     (S)
+      CHECK(data3 == data4); // bitset_ext (S) == bitset_ext (M)
+      CHECK(data4 == data3); // bitset_ext (M) == bitset_ext (S)
+      CHECK(data1 == data4); // bitset     (S) == bitset_ext (M)
+      CHECK(data4 == data1); // bitset_ext (M) == bitset     (S)
+      CHECK(data2 == data3); // bitset     (M) == bitset_ext (S)
+      CHECK(data3 == data2); // bitset_ext (S) == bitset     (M)
+    }
+
+    //*************************************************************************
+    TEST(test_inequality_mixed_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456784012345ULL);
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data3(0x0123456787012345ULL, buffer3);
+      etl::bitset_ext<64> data4(0x0123426789012345ULL, buffer4);
+
+      // Double check we are using the single/multi element storage model.
+      CHECK(etl::bitset_storage_model::Single == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi  == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi  == data4.Storage_Model);
+
+      CHECK(data1 != data2); // bitset     (S) != bitset     (M)
+      CHECK(data2 != data1); // bitset     (M) != bitset     (S)
+      CHECK(data3 != data4); // bitset_ext (S) != bitset_ext (M)
+      CHECK(data4 != data3); // bitset_ext (M) != bitset_ext (S)
+      CHECK(data1 != data4); // bitset     (S) != bitset_ext (M)
+      CHECK(data4 != data1); // bitset_ext (M) != bitset     (S)
+      CHECK(data2 != data3); // bitset     (M) != bitset_ext (S)
+      CHECK(data3 != data2); // bitset_ext (S) != bitset     (M) 
+    }
+
+    //*************************************************************************
+    TEST(test_equality_mixed_storage_model_different_element_types)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint32_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint8_t>  data2(0x0123456789012345ULL);
+
+      etl::bitset_ext<64, uint32_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint8_t>::buffer_type  buffer4;
+      etl::bitset_ext<64, uint32_t> data3(0x0123456789012345ULL, buffer3);
+      etl::bitset_ext<64, uint8_t>  data4(0x0123456789012345ULL, buffer4);
+
+      // Double check we are using the multi element storage model.
+      CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model);
+
+      CHECK(data1 == data2); // bitset     (S) == bitset     (M)
+      CHECK(data2 == data1); // bitset     (M) == bitset     (S)
+      CHECK(data3 == data4); // bitset_ext (S) == bitset_ext (M)
+      CHECK(data4 == data3); // bitset_ext (M) == bitset_ext (S)
+      CHECK(data1 == data4); // bitset     (S) == bitset_ext (M)
+      CHECK(data4 == data1); // bitset_ext (M) == bitset     (S)
+      CHECK(data2 == data3); // bitset     (M) == bitset_ext (S)
+      CHECK(data3 == data2); // bitset_ext (S) == bitset     (M)
+    }
+
+    //*************************************************************************
+    TEST(test_inequality_mixed_storage_model_different_element_types)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint32_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint8_t>  data2(0x0123456784012345ULL);
+
+      etl::bitset_ext<64, uint32_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint8_t>::buffer_type  buffer4;
+      etl::bitset_ext<64, uint32_t> data3(0x0123456787012345ULL, buffer3);
+      etl::bitset_ext<64, uint8_t>  data4(0x0123426789012345ULL, buffer4);
+
+      // Double check we are using the multi element storage model.
+      CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model);
+
+      CHECK(data1 != data2); // bitset     (S) != bitset     (M)
+      CHECK(data2 != data1); // bitset     (M) != bitset     (S)
+      CHECK(data3 != data4); // bitset_ext (S) != bitset_ext (M)
+      CHECK(data4 != data3); // bitset_ext (M) != bitset_ext (S)
+      CHECK(data1 != data4); // bitset     (S) != bitset_ext (M)
+      CHECK(data4 != data1); // bitset_ext (M) != bitset     (S)
+      CHECK(data2 != data3); // bitset     (M) != bitset_ext (S)
+      CHECK(data3 != data2); // bitset_ext (S) != bitset     (M)
+    }
+  };
+}
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index b22f5a44..1a38ef2b 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -37,6 +37,7 @@ SOFTWARE.
 #include "etl/wstring.h"
 #include "etl/u16string.h"
 #include "etl/u32string.h"
+#include "etl/endianness.h"
 
 namespace
 {
@@ -46,9 +47,22 @@ namespace
   template <size_t Active_Bits>
   ETL_CONSTEXPR14 etl::bitset<Active_Bits> generate_shift_left_bitset(ull value, size_t shift)
   {
+    ull mask = 0ULL;
+
+    if (shift < 64U)
+    {
+      mask = etl::integral_limits<ull>::max >> shift;
+    }
+
+    value &= mask;
+
     etl::bitset<Active_Bits> data(value);
 
-    if (shift != 0U)
+    if (shift >= 64U)
+    {
+      data.reset();
+    }
+    else if (shift != 0U)
     {
       data <<= shift;
     }
@@ -63,7 +77,7 @@ namespace
     etl::bitset<Active_Bits> data1(value);
     etl::bitset<Active_Bits> data2;
 
-    if (shift != 0U)
+    if ((shift != 0U) && (shift != 64U))
     {
       data2 = data1 << shift;
     }
@@ -77,7 +91,11 @@ namespace
   {
     etl::bitset<Active_Bits> data(value);
 
-    if (shift != 0U)
+    if (shift >= 64U)
+    {
+      data.reset();
+    }
+    else if (shift != 0U)
     {
       data >>= shift;
     }
@@ -105,10 +123,10 @@ namespace
     //*************************************************************************
     TEST(test_default_constructor)
     {
-      ETL_CONSTEXPR14 std::bitset<60> compare;
-      ETL_CONSTEXPR14 etl::bitset<60> data;
+      ETL_CONSTEXPR14 std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data;
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -118,715 +136,41 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_default_constructor_multi_element)
+    TEST(test_default_constructor_single_element)
     {
-      etl::bitset<14, int8_t>  data8;
-      etl::bitset<30, int16_t> data16;
-      etl::bitset<62, int32_t> data32;
+      etl::bitset<8>  data8;
+      etl::bitset<16> data16;
+      etl::bitset<32> data32;
+      etl::bitset<64> data64;
 
-      CHECK_EQUAL(2U, data8.Number_Of_Elements);
-      CHECK_EQUAL(2U, data16.Number_Of_Elements);
-      CHECK_EQUAL(2U, data32.Number_Of_Elements);
-    }
+      using element_type  = etl::bitset<8>::element_type;
+      size_t element_bits = etl::integral_limits<element_type>::bits;
 
-    //*************************************************************************
-    TEST(test_default_constructor_default_element_type_bits)
-    {
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<1>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<2>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<3>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<4>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<5>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<6>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<7>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<8>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<9>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<10>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<11>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<12>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<13>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<14>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<15>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<16>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<17>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<18>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<19>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<20>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<21>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<22>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<23>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<24>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<25>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<26>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<27>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<28>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<29>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<30>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<31>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<32>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<33>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<34>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<35>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<36>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<37>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<38>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<39>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<40>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<41>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<42>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<43>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<44>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<45>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<46>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<47>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<48>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<49>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<50>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<51>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<52>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<53>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<54>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<55>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<56>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<57>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<58>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<59>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<60>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<61>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<62>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<63>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<64>::element_type>::bits);
-    }
-     
-    //*************************************************************************
-    TEST(test_default_constructor_default_element_type_number_of_elements)
-    {
-      CHECK_EQUAL(1U, etl::bitset<1>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<2>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<3>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<4>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<5>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<6>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<7>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<8>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<9>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<10>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<11>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<12>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<13>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<14>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<15>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<16>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<17>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<18>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<19>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<20>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<21>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<22>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<23>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<24>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<25>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<26>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<27>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<28>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<29>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<30>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<31>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<32>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<33>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<34>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<35>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<36>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<37>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<38>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<39>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<40>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<41>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<42>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<43>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<44>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<45>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<46>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<47>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<48>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<49>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<50>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<51>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<52>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<53>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<54>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<55>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<56>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<57>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<58>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<59>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<60>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<61>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<62>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<63>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<64>::Number_Of_Elements);
-    }
+      CHECK_EQUAL(8,  data8.Size);
+      CHECK_EQUAL(16, data16.Size);
+      CHECK_EQUAL(32, data32.Size);
+      CHECK_EQUAL(64, data64.Size);
 
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int8_t_element_types_bits)
-    {
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<1, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<2, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<3, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<4, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<5, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<6, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<7, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<8, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<9, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<10, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<11, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<12, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<13, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<14, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<15, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<16, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<17, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<18, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<19, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<20, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<21, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<22, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<23, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<24, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<25, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<26, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<27, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<28, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<29, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<30, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<31, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<32, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<33, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<34, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<35, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<36, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<37, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<38, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<39, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<40, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<41, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<42, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<43, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<44, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<45, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<46, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<47, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<48, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<49, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<50, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<51, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<52, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<53, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<54, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<55, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<56, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<57, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<58, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<59, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<60, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<61, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<62, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<63, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<64, int8_t>::element_type>::bits));
-    }
+      CHECK_EQUAL( 8 / element_bits, data8.Number_Of_Elements);
+      CHECK_EQUAL(16 / element_bits, data16.Number_Of_Elements);
+      CHECK_EQUAL(32 / element_bits, data32.Number_Of_Elements);
+      CHECK_EQUAL(64 / element_bits, data64.Number_Of_Elements);
 
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int8_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset<1, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<2, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<3, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<4, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<5, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<6, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<7, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<8, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<9, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<10, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<11, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<12, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<13, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<14, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<15, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<16, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<17, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<18, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<19, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<20, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<21, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<22, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<23, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<24, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<25, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<26, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<27, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<28, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<29, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<30, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<31, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<32, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<33, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<34, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<35, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<36, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<37, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<38, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<39, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<40, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<41, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<42, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<43, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<44, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<45, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<46, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<47, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<48, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<49, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<50, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<51, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<52, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<53, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<54, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<55, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<56, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<57, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<58, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<59, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<60, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<61, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<62, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<63, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<64, int8_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int16_t_element_types_bits)
-    {
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<1, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<2, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<3, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<4, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<5, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<6, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<7, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<8, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<9, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<10, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<11, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<12, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<13, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<14, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<15, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<16, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<17, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<18, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<19, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<20, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<21, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<22, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<23, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<24, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<25, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<26, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<27, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<28, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<29, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<30, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<31, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<32, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<33, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<34, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<35, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<36, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<37, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<38, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<39, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<40, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<41, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<42, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<43, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<44, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<45, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<46, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<47, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<48, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<49, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<50, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<51, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<52, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<53, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<54, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<55, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<56, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<57, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<58, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<59, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<60, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<61, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<62, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<63, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<64, int16_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int16_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset<1, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<2, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<3, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<4, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<5, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<6, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<7, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<8, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<9, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<10, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<11, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<12, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<13, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<14, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<15, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<16, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<17, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<18, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<19, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<20, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<21, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<22, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<23, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<24, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<25, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<26, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<27, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<28, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<29, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<30, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<31, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<32, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<33, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<34, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<35, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<36, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<37, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<38, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<39, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<40, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<41, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<42, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<43, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<44, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<45, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<46, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<47, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<48, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<49, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<50, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<51, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<52, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<53, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<54, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<55, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<56, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<57, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<58, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<59, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<60, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<61, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<62, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<63, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<64, int16_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int32_t_element_types_bits)
-    {
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<1, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<2, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<3, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<4, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<5, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<6, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<7, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<8, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<9, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<10, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<11, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<12, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<13, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<14, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<15, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<16, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<17, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<18, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<19, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<20, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<21, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<22, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<23, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<24, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<25, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<26, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<27, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<28, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<29, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<30, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<31, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<32, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<33, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<34, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<35, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<36, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<37, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<38, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<39, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<40, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<41, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<42, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<43, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<44, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<45, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<46, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<47, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<48, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<49, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<50, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<51, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<52, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<53, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<54, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<55, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<56, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<57, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<58, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<59, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<60, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<61, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<62, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<63, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<64, int32_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int32_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset<1, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<2, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<3, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<4, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<5, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<6, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<7, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<8, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<9, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<10, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<11, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<12, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<13, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<14, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<15, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<16, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<17, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<18, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<19, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<20, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<21, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<22, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<23, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<24, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<25, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<26, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<27, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<28, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<29, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<30, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<31, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<32, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<33, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<34, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<35, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<36, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<37, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<38, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<39, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<40, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<41, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<42, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<43, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<44, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<45, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<46, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<47, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<48, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<49, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<50, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<51, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<52, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<53, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<54, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<55, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<56, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<57, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<58, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<59, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<60, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<61, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<62, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<63, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<64, int32_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int64_t_element_types_bits)
-    {
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<1, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<2, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<3, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<4, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<5, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<6, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<7, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<8, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<9, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<10, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<11, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<12, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<13, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<14, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<15, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<16, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<17, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<18, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<19, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<20, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<21, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<22, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<23, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<24, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<25, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<26, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<27, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<28, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<29, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<30, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<31, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<32, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<33, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<34, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<35, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<36, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<37, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<38, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<39, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<40, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<41, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<42, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<43, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<44, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<45, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<46, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<47, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<48, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<49, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<50, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<51, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<52, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<53, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<54, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<55, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<56, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<57, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<58, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<59, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<60, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<61, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<62, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<63, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<64, int64_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int64_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset<1, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<2, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<3, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<4, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<5, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<6, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<7, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<8, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<9, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<10, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<11, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<12, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<13, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<14, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<15, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<16, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<17, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<18, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<19, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<20, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<21, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<22, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<23, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<24, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<25, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<26, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<27, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<28, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<29, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<30, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<31, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<32, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<33, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<34, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<35, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<36, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<37, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<38, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<39, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<40, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<41, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<42, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<43, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<44, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<45, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<46, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<47, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<48, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<49, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<50, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<51, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<52, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<53, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<54, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<55, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<56, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<57, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<58, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<59, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<60, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<61, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<62, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<63, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<64, int64_t>::Number_Of_Elements));
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data8.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Multi,  data16.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Multi,  data32.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Multi,  data64.Storage_Model);
     }
 
     //*************************************************************************
     TEST(test_construct_from_value)
     {
-      ETL_CONSTEXPR14 std::bitset<60> compare(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data(0x123456731234567ULL);
+      ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(0x123456731234567ULL);
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
+      CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -837,9 +181,9 @@ namespace
     //*************************************************************************
     TEST(test_copy_construct)
     {
-      ETL_CONSTEXPR14 std::bitset<60> compare(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data_copy(data);
+      ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(0x123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data_copy(data);
 
       CHECK_EQUAL(compare.size(), data_copy.size());
       CHECK_EQUAL(compare.count(), data_copy.count());
@@ -853,10 +197,10 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_excess_value)
     {
-      ETL_CONSTEXPR14 std::bitset<60> compare(0x8765432187654321ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data(0x8765432187654321ULL);
+      ETL_CONSTEXPR14 std::bitset<64> compare(0x8765432187654321ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(0x8765432187654321ULL);
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -868,10 +212,10 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char_string)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001");
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data("110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -883,8 +227,8 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_wchar_t_string)
     {
-      std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data(L"110001001000110100010101100111001100010010001101000101011001");
+      std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data(L"110001001000110100010101100111001100010010001101000101011001");
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -898,8 +242,8 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char16_t_string)
     {
-      std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data(u"110001001000110100010101100111001100010010001101000101011001");
+      std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data(u"110001001000110100010101100111001100010010001101000101011001");
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -913,8 +257,8 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char32_t_string)
     {
-      std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data(U"110001001000110100010101100111001100010010001101000101011001");
+      std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data(U"110001001000110100010101100111001100010010001101000101011001");
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -947,7 +291,6 @@ namespace
       CHECK_EQUAL(0, data.count());
     }
 
-
     //*************************************************************************
     TEST(test_construct_from_nullptr_char16_t_string)
     {
@@ -973,8 +316,8 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_excess_string)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001111100001");
-      etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001111100001");
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001");
+      etl::bitset<64> data("110001001000110100010101100111001100010010001101000101011001111100001");
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -982,6 +325,8 @@ namespace
       CHECK_EQUAL(compare.any(),   data.any());
       CHECK_EQUAL(compare.all(),   data.all());
 
+      CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong());
+
       for (size_t i = 0UL; i < data.size(); ++i)
       {
         CHECK_EQUAL(compare.test(i), data.test(i));
@@ -989,7 +334,41 @@ namespace
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_helper()
+    {
+      etl::bitset<64> data;
+      data.set();
+
+      return data;
+    }
+
     TEST(test_set)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_helper());
+
+      compare.set();
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_less_than_full_size)
     {
       std::bitset<60> compare;
       etl::bitset<60> data;
@@ -997,11 +376,17 @@ namespace
       compare.set();
       data.set();
 
-      CHECK_EQUAL(compare.size(), data.size());
-      CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1012,8 +397,8 @@ namespace
     //*************************************************************************
     TEST(test_set_with_char_string)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.set("110001001000110100010101100111001100010010001101000101011001");
 
@@ -1032,16 +417,16 @@ namespace
     //*************************************************************************
     TEST(test_set_with_wchar_t_string)
     {
-      std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.set(L"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1052,16 +437,16 @@ namespace
     //*************************************************************************
     TEST(test_set_with_char16_t_string)
     {
-      std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.set(u"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1072,16 +457,16 @@ namespace
     //*************************************************************************
     TEST(test_set_with_char32_t_string)
     {
-      std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.set(U"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1140,8 +525,8 @@ namespace
     //*************************************************************************
     TEST(test_from_string_with_char)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.from_string("110001001000110100010101100111001100010010001101000101011001");
 
@@ -1160,8 +545,8 @@ namespace
     //*************************************************************************
     TEST(test_from_string_with_wchar_t)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.from_string(L"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1178,10 +563,10 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char16_t_6string)
+    TEST(test_from_string_with_char16_t)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.from_string(u"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1200,8 +585,8 @@ namespace
     //*************************************************************************
     TEST(test_from_string_with_char32_t)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.from_string(U"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1265,6 +650,42 @@ namespace
       CHECK_EQUAL(0, data.count());
     }
 
+    //*************************************************************************
+    TEST(test_value_u8_min)
+    {
+      ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits<uint8_t>::min);
+      ETL_CONSTEXPR14 uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_u8_max)
+    {
+      ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits<uint8_t>::max);
+      ETL_CONSTEXPR14 uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_s8_min)
+    {
+      ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits<int8_t>::min);
+      ETL_CONSTEXPR14 int8_t value = data.value<int8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<int8_t>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_s8_max)
+    {
+      ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits<int8_t>::max);
+      ETL_CONSTEXPR14 int8_t value = data.value<int8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<int8_t>::max(), value);
+    }
+
     //*************************************************************************
     TEST(test_value_u16_min)
     {
@@ -1304,19 +725,19 @@ namespace
     //*************************************************************************
     TEST(test_value_u32_min)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits<uint32_t>::min);
-      ETL_CONSTEXPR14 uint32_t value = data.value<uint32_t>();
+      ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits<int32_t>::min);
+      ETL_CONSTEXPR14 int32_t value = data.value<int32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<uint32_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<int32_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u32_max)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits<uint32_t>::max);
-      ETL_CONSTEXPR14 uint32_t value = data.value<uint32_t>();
+      ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits<int32_t>::max);
+      ETL_CONSTEXPR14 int32_t value = data.value<int32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<uint32_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<int32_t>::max(), value);
     }
 
     //*************************************************************************
@@ -1340,26 +761,26 @@ namespace
     //*************************************************************************
     TEST(test_value_u64_min)
     {
-      ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<uint64_t>::min);
-      ETL_CONSTEXPR14 uint64_t value = data.value<uint64_t>();
+      ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::min);
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<uint64_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u64_max)
     {
-      ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<uint64_t>::max);
-      ETL_CONSTEXPR14 uint64_t value = data.value<uint64_t>();
+      ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::max);
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<uint64_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s64_min)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::min);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
     }
@@ -1368,7 +789,7 @@ namespace
     TEST(test_value_s64_max)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::max);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
     }
@@ -1376,8 +797,8 @@ namespace
     //*************************************************************************
     TEST(test_position_set)
     {
-      std::bitset<60> compare;
-      etl::bitset<60> data;
+      std::bitset<64> compare;
+      etl::bitset<64> data;
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1406,13 +827,20 @@ namespace
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_reset_helper()
+    {
+      etl::bitset<64> data(0xFFFFFFFFFFFFFFFULL);
+      data.reset();
+
+      return data;
+    }
+
     TEST(test_reset)
     {
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset<60> data(0xFFFFFFFFFFFFFFFULL);
+      std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_reset_helper());
 
       compare.reset();
-      data.reset();
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -1427,21 +855,27 @@ namespace
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_position_reset_helper()
+    {
+      etl::bitset<64> data(0xFFFFFFFFFFFFFFFULL);
+      data.reset(1);
+      data.reset(3);
+      data.reset(7);
+      data.reset(13);
+
+      return data;
+    }
+
     TEST(test_position_reset)
     {
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset<60> data(0xFFFFFFFFFFFFFFFULL);
+      std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_position_reset_helper());
 
       compare.reset(1);
       compare.reset(3);
       compare.reset(7);
       compare.reset(13);
 
-      data.reset(1);
-      data.reset(3);
-      data.reset(7);
-      data.reset(13);
-
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
       CHECK_EQUAL(compare.none(), data.none());
@@ -1481,8 +915,8 @@ namespace
     //*************************************************************************
     TEST(test_index_operator_read)
     {
-      ETL_CONSTEXPR14 std::bitset<60> compare(0x3123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data(0x3123456731234567ULL);
+      ETL_CONSTEXPR14 std::bitset<64> compare(0x3123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(0x3123456731234567ULL);
 
       ETL_CONSTEXPR14 bool bc0 = compare[1U];
       ETL_CONSTEXPR14 bool bd0 = data[1U];
@@ -1502,15 +936,22 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_index_operator_write)
+    ETL_CONSTEXPR14 etl::bitset<64> test_index_operator_write_helper()
     {
-      etl::bitset<60> data;
+      etl::bitset<64> data;
 
       data[1U] = true;
       data[3U] = true;
       data[7U] = true;
       data[13U] = true;
 
+      return data;
+    }
+
+    TEST(test_index_operator_write)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_index_operator_write_helper());
+
       CHECK(data[1U]);
       CHECK(data[3U]);
       CHECK(data[7U]);
@@ -1520,10 +961,10 @@ namespace
     //*************************************************************************
     TEST(test_any)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.any();
       ETL_CONSTEXPR14 bool bd2 = data2.any();
@@ -1539,10 +980,10 @@ namespace
     //*************************************************************************
     TEST(test_none)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.none();
       ETL_CONSTEXPR14 bool bd2 = data2.none();
@@ -1558,10 +999,10 @@ namespace
     //*************************************************************************
     TEST(test_all)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.all();
       ETL_CONSTEXPR14 bool bd2 = data2.all();
@@ -1575,13 +1016,77 @@ namespace
     }
 
     //*************************************************************************
+    TEST(test_any_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.any();
+      ETL_CONSTEXPR14 bool bd2 = data2.any();
+      ETL_CONSTEXPR14 bool bd3 = data3.any();
+      ETL_CONSTEXPR14 bool bd4 = data4.any();
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.none();
+      ETL_CONSTEXPR14 bool bd2 = data2.none();
+      ETL_CONSTEXPR14 bool bd3 = data3.none();
+      ETL_CONSTEXPR14 bool bd4 = data4.none();
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.all();
+      ETL_CONSTEXPR14 bool bd2 = data2.all();
+      ETL_CONSTEXPR14 bool bd3 = data3.all();
+      ETL_CONSTEXPR14 bool bd4 = data4.all();
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_flip_helper()
+    {
+      etl::bitset<64> data;
+      data.flip();
+
+      return data;
+    }
+
     TEST(test_flip)
     {
-      std::bitset<60> compare;
-      etl::bitset<60> data;
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_flip_helper());
 
       compare.flip();
-      data.flip();
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1590,21 +1095,27 @@ namespace
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_flip_position_helper()
+    {
+      etl::bitset<64> data;
+      data.flip(1);
+      data.flip(3);
+      data.flip(7);
+      data.flip(13);
+
+      return data;
+    }
+
     TEST(test_flip_position)
     {
-      std::bitset<60> compare;
-      etl::bitset<60> data;
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_flip_position_helper());
 
       compare.flip(1);
       compare.flip(3);
       compare.flip(7);
       compare.flip(13);
 
-      data.flip(1);
-      data.flip(3);
-      data.flip(7);
-      data.flip(13);
-
       for (size_t i = 0UL; i < data.size(); ++i)
       {
         CHECK_EQUAL(compare.test(i), data.test(i));
@@ -1612,21 +1123,27 @@ namespace
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_flip_reference_helper()
+    {
+      etl::bitset<64> data;
+      data[1].flip();
+      data[3].flip();
+      data[7].flip();
+      data[13].flip();
+
+      return data;
+    }
+
     TEST(test_flip_reference)
     {
-      std::bitset<60> compare;
-      etl::bitset<60> data;
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_flip_reference_helper());
 
       compare[1].flip();
       compare[3].flip();
       compare[7].flip();
       compare[13].flip();
 
-      data[1].flip();
-      data[3].flip();
-      data[7].flip();
-      data[13].flip();
-
       for (size_t i = 0UL; i < data.size(); ++i)
       {
         CHECK_EQUAL(compare.test(i), data.test(i));
@@ -1636,8 +1153,8 @@ namespace
     //*************************************************************************
     TEST(test_invert_reference)
     {
-      std::bitset<60> compare;
-      etl::bitset<60> data;
+      std::bitset<64> compare;
+      etl::bitset<64> data;
 
       bool bc = ~compare[3];
       bool bd = ~data[3];
@@ -1645,18 +1162,18 @@ namespace
     }
 
     //*************************************************************************
-    void test_assignment_operator_helper(etl::bitset<60>& from, etl::bitset<60>& to)
+    ETL_CONSTEXPR14 etl::bitset<64> test_assignment_operator_helper(etl::bitset<64> to, const etl::bitset<64>&from)
     {
       to = from;
+
+      return to;
     }
 
     TEST(test_assignment_operator)
     {
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset<60> data1(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset<60> data2;
-
-      test_assignment_operator_helper(data1, data2);
+      ETL_CONSTEXPR14 std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0xFFFFFFFFFFFFFFFULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(test_assignment_operator_helper(etl::bitset<64>(), data1));
 
       for (size_t i = 0UL; i < data2.size(); ++i)
       {
@@ -1667,11 +1184,11 @@ namespace
     //*************************************************************************
     TEST(test_equality_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> data1(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data2(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data3;
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data3;
 
-      ETL_CONSTEXPR14 bool equal     =  (data1 == data2);
+      ETL_CONSTEXPR14 bool equal = (data1 == data2);
       ETL_CONSTEXPR14 bool not_equal = !(data1 == data3);
 
       CHECK(equal);
@@ -1681,9 +1198,9 @@ namespace
     //*************************************************************************
     TEST(test_inequality_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> data1(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data2(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data3;
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data3;
 
       ETL_CONSTEXPR14 bool equal = !(data1 != data2);
       ETL_CONSTEXPR14 bool not_equal = (data1 != data3);
@@ -1695,139 +1212,138 @@ namespace
     //*************************************************************************
     TEST(test_shift_left_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> shift1(0x2468ACF0ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> shift2(0x48D159E0ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> shift11(0x91A2B3C000ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift1(0x2468ACF0ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift2(0x48D159E0ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift11(0x91A2B3C000ULL);
 
-      CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 1U) == shift1);
-      CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 2U) == shift2);
-      CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 11U) == shift11);
+      CHECK((generate_shift_left_bitset<64>(0x12345678ULL, 1U)) == shift1);
+      CHECK((generate_shift_left_bitset<64>(0x12345678ULL, 2U)) == shift2);
+      CHECK((generate_shift_left_bitset<64>(0x12345678ULL, 11U)) == shift11);
     }
 
     //*************************************************************************
     TEST(test_shift_left_operator_overflow)
     {
-      ETL_CONSTEXPR14 etl::bitset<31> data(generate_shift_left_bitset<31>(0x7FFFFFFFULL, 1U));
-      ETL_CONSTEXPR14 etl::bitset<31> shifted(0x7FFFFFFEUL);
+      ETL_CONSTEXPR14 etl::bitset<32> data(generate_shift_left_bitset<32>(0x7FFFFFFFULL, 1U));
+      ETL_CONSTEXPR14 etl::bitset<32> shifted(0xFFFFFFFEUL);
 
-      CHECK(data == shifted);
+      CHECK_EQUAL_HEX(shifted.value<uint32_t>(), data.value<uint32_t>());
     }
 
     //*************************************************************************
     TEST(test_shift_left_copy_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> shift8(0x1234567800ULL);
-      CHECK_EQUAL_HEX(shift8.value<uint64_t>(), generate_shift_left_bitset_copy<60>(0x12345678UL, 8U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift8(0x1234567800ULL);
+      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 8U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift16(0x123456780000ULL);
-      CHECK_EQUAL_HEX(shift16.value<uint64_t>(), generate_shift_left_bitset_copy<60>(0x12345678UL, 16U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift16(0x123456780000ULL);
+      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 16U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift24(0x12345678000000ULL);
-      CHECK_EQUAL_HEX(shift24.value<uint64_t>(), generate_shift_left_bitset_copy<60>(0x12345678UL, 24U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift24(0x12345678000000ULL);
+      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 24U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift60(0x0000000000000000ULL);
-      CHECK_EQUAL_HEX(shift60.value<uint64_t>(), generate_shift_left_bitset_copy<60>(0x12345678UL, 60U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift64(0x0000000000000000ULL);
+      CHECK_EQUAL_HEX(shift64.value<int64_t>(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
-    TEST(test_shift_left_operator_all_shifts_partial_size)
+    TEST(test_shift_left_operator_all_shifts_full_size)
     {
       uint64_t value = 0x0123456789ABCDEFULL;
-      uint64_t mask  = 0x0FFFFFFFFFFFFFFFULL;
 
-      CHECK_EQUAL_HEX((value << 0U) & mask, (generate_shift_left_bitset<60>(value, 0U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 1U) & mask, (generate_shift_left_bitset<60>(value, 1U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 2U) & mask, (generate_shift_left_bitset<60>(value, 2U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 3U) & mask, (generate_shift_left_bitset<60>(value, 3U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 4U) & mask, (generate_shift_left_bitset<60>(value, 4U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 5U) & mask, (generate_shift_left_bitset<60>(value, 5U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 6U) & mask, (generate_shift_left_bitset<60>(value, 6U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 7U) & mask, (generate_shift_left_bitset<60>(value, 7U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 8U) & mask, (generate_shift_left_bitset<60>(value, 8U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 9U) & mask, (generate_shift_left_bitset<60>(value, 9U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 10U) & mask, (generate_shift_left_bitset<60>(value, 10U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 11U) & mask, (generate_shift_left_bitset<60>(value, 11U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 12U) & mask, (generate_shift_left_bitset<60>(value, 12U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 13U) & mask, (generate_shift_left_bitset<60>(value, 13U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 14U) & mask, (generate_shift_left_bitset<60>(value, 14U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 15U) & mask, (generate_shift_left_bitset<60>(value, 15U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 16U) & mask, (generate_shift_left_bitset<60>(value, 16U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 17U) & mask, (generate_shift_left_bitset<60>(value, 17U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 18U) & mask, (generate_shift_left_bitset<60>(value, 18U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 19U) & mask, (generate_shift_left_bitset<60>(value, 19U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 20U) & mask, (generate_shift_left_bitset<60>(value, 20U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 21U) & mask, (generate_shift_left_bitset<60>(value, 21U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 22U) & mask, (generate_shift_left_bitset<60>(value, 22U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 23U) & mask, (generate_shift_left_bitset<60>(value, 23U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 24U) & mask, (generate_shift_left_bitset<60>(value, 24U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 25U) & mask, (generate_shift_left_bitset<60>(value, 25U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 26U) & mask, (generate_shift_left_bitset<60>(value, 26U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 27U) & mask, (generate_shift_left_bitset<60>(value, 27U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 28U) & mask, (generate_shift_left_bitset<60>(value, 28U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 29U) & mask, (generate_shift_left_bitset<60>(value, 29U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 30U) & mask, (generate_shift_left_bitset<60>(value, 30U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 31U) & mask, (generate_shift_left_bitset<60>(value, 31U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 32U) & mask, (generate_shift_left_bitset<60>(value, 32U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 33U) & mask, (generate_shift_left_bitset<60>(value, 33U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 34U) & mask, (generate_shift_left_bitset<60>(value, 34U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 35U) & mask, (generate_shift_left_bitset<60>(value, 35U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 36U) & mask, (generate_shift_left_bitset<60>(value, 36U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 37U) & mask, (generate_shift_left_bitset<60>(value, 37U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 38U) & mask, (generate_shift_left_bitset<60>(value, 38U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 39U) & mask, (generate_shift_left_bitset<60>(value, 39U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 40U) & mask, (generate_shift_left_bitset<60>(value, 40U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 41U) & mask, (generate_shift_left_bitset<60>(value, 41U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 42U) & mask, (generate_shift_left_bitset<60>(value, 42U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 43U) & mask, (generate_shift_left_bitset<60>(value, 43U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 44U) & mask, (generate_shift_left_bitset<60>(value, 44U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 45U) & mask, (generate_shift_left_bitset<60>(value, 45U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 46U) & mask, (generate_shift_left_bitset<60>(value, 46U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 47U) & mask, (generate_shift_left_bitset<60>(value, 47U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 48U) & mask, (generate_shift_left_bitset<60>(value, 48U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 49U) & mask, (generate_shift_left_bitset<60>(value, 49U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 50U) & mask, (generate_shift_left_bitset<60>(value, 50U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 51U) & mask, (generate_shift_left_bitset<60>(value, 51U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 52U) & mask, (generate_shift_left_bitset<60>(value, 52U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 53U) & mask, (generate_shift_left_bitset<60>(value, 53U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 54U) & mask, (generate_shift_left_bitset<60>(value, 54U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 55U) & mask, (generate_shift_left_bitset<60>(value, 55U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 56U) & mask, (generate_shift_left_bitset<60>(value, 56U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 57U) & mask, (generate_shift_left_bitset<60>(value, 57U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 58U) & mask, (generate_shift_left_bitset<60>(value, 58U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 59U) & mask, (generate_shift_left_bitset<60>(value, 59U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 60U) & mask, (generate_shift_left_bitset<60>(value, 60U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 61U) & mask, (generate_shift_left_bitset<60>(value, 61U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 62U) & mask, (generate_shift_left_bitset<60>(value, 62U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 63U) & mask, (generate_shift_left_bitset<60>(value, 63U).value<uint64_t>()));
-      CHECK_EQUAL_HEX(0ULL,                  (generate_shift_left_bitset<60>(value, 64U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 0U), (generate_shift_left_bitset<64>(value, 0U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 1U), (generate_shift_left_bitset<64>(value, 1U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 2U), (generate_shift_left_bitset<64>(value, 2U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 3U), (generate_shift_left_bitset<64>(value, 3U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 4U), (generate_shift_left_bitset<64>(value, 4U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 5U), (generate_shift_left_bitset<64>(value, 5U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 6U), (generate_shift_left_bitset<64>(value, 6U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 7U), (generate_shift_left_bitset<64>(value, 7U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 8U), (generate_shift_left_bitset<64>(value, 8U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 9U), (generate_shift_left_bitset<64>(value, 9U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 10U), (generate_shift_left_bitset<64>(value, 10U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 11U), (generate_shift_left_bitset<64>(value, 11U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 12U), (generate_shift_left_bitset<64>(value, 12U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 13U), (generate_shift_left_bitset<64>(value, 13U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 14U), (generate_shift_left_bitset<64>(value, 14U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 15U), (generate_shift_left_bitset<64>(value, 15U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 16U), (generate_shift_left_bitset<64>(value, 16U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 17U), (generate_shift_left_bitset<64>(value, 17U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 18U), (generate_shift_left_bitset<64>(value, 18U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 19U), (generate_shift_left_bitset<64>(value, 19U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 20U), (generate_shift_left_bitset<64>(value, 20U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 21U), (generate_shift_left_bitset<64>(value, 21U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 22U), (generate_shift_left_bitset<64>(value, 22U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 23U), (generate_shift_left_bitset<64>(value, 23U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 24U), (generate_shift_left_bitset<64>(value, 24U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 25U), (generate_shift_left_bitset<64>(value, 25U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 26U), (generate_shift_left_bitset<64>(value, 26U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 27U), (generate_shift_left_bitset<64>(value, 27U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 28U), (generate_shift_left_bitset<64>(value, 28U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 29U), (generate_shift_left_bitset<64>(value, 29U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 30U), (generate_shift_left_bitset<64>(value, 30U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 31U), (generate_shift_left_bitset<64>(value, 31U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 32U), (generate_shift_left_bitset<64>(value, 32U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 33U), (generate_shift_left_bitset<64>(value, 33U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 34U), (generate_shift_left_bitset<64>(value, 34U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 35U), (generate_shift_left_bitset<64>(value, 35U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 36U), (generate_shift_left_bitset<64>(value, 36U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 37U), (generate_shift_left_bitset<64>(value, 37U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 38U), (generate_shift_left_bitset<64>(value, 38U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 39U), (generate_shift_left_bitset<64>(value, 39U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 40U), (generate_shift_left_bitset<64>(value, 40U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 41U), (generate_shift_left_bitset<64>(value, 41U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 42U), (generate_shift_left_bitset<64>(value, 42U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 43U), (generate_shift_left_bitset<64>(value, 43U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 44U), (generate_shift_left_bitset<64>(value, 44U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 45U), (generate_shift_left_bitset<64>(value, 45U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 46U), (generate_shift_left_bitset<64>(value, 46U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 47U), (generate_shift_left_bitset<64>(value, 47U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 48U), (generate_shift_left_bitset<64>(value, 48U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 49U), (generate_shift_left_bitset<64>(value, 49U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 50U), (generate_shift_left_bitset<64>(value, 50U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 51U), (generate_shift_left_bitset<64>(value, 51U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 52U), (generate_shift_left_bitset<64>(value, 52U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 53U), (generate_shift_left_bitset<64>(value, 53U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 54U), (generate_shift_left_bitset<64>(value, 54U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 55U), (generate_shift_left_bitset<64>(value, 55U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 56U), (generate_shift_left_bitset<64>(value, 56U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 57U), (generate_shift_left_bitset<64>(value, 57U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 58U), (generate_shift_left_bitset<64>(value, 58U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 59U), (generate_shift_left_bitset<64>(value, 59U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 60U), (generate_shift_left_bitset<64>(value, 60U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 61U), (generate_shift_left_bitset<64>(value, 61U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 62U), (generate_shift_left_bitset<64>(value, 62U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 63U), (generate_shift_left_bitset<64>(value, 63U).value<uint64_t>()));
+      CHECK_EQUAL_HEX(0ULL, (generate_shift_left_bitset<64>(value, 64U).value<uint64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> shift1(0x91A2B3CULL);
-      ETL_CONSTEXPR14 etl::bitset<60> shift2(0x48D159EULL);
-      ETL_CONSTEXPR14 etl::bitset<60> shift11(0x2468AULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift1(0x91A2B3CULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift2(0x48D159EULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift11(0x2468AULL);
 
-      CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 1U) == shift1);
-      CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 2U) == shift2);
-      CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 11U) == shift11);
+      CHECK_EQUAL_HEX(shift1.value<int64_t>(), (generate_shift_right_bitset<64>(0x12345678ULL, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX(shift2.value<int64_t>(), (generate_shift_right_bitset<64>(0x12345678ULL, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX(shift11.value<int64_t>(), (generate_shift_right_bitset<64>(0x12345678ULL, 11U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_copy_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> shift8(0x123456ULL);
-      CHECK_EQUAL_HEX(shift8.value<uint64_t>(), generate_shift_right_bitset_copy<60>(0x12345678UL, 8U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift8(0x123456ULL);
+      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 8U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift16(0x1234ULL);
-      CHECK_EQUAL_HEX(shift16.value<uint64_t>(), generate_shift_right_bitset_copy<60>(0x12345678UL, 16U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift16(0x1234ULL);
+      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 16U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift24(0x12ULL);
-      CHECK_EQUAL_HEX(shift24.value<uint64_t>(), generate_shift_right_bitset_copy<60>(0x12345678UL, 24U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift24(0x12ULL);
+      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 24U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift60(0x00ULL);
-      CHECK_EQUAL_HEX(shift60.value<uint64_t>(), generate_shift_right_bitset_copy<60>(0x12345678UL, 60U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift60(0x00ULL);
+      CHECK_EQUAL_HEX(shift60.value<int64_t>(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 60U).value<int64_t>()));
     }
 
     //*************************************************************************
@@ -1835,331 +1351,335 @@ namespace
     {
       uint64_t value = 0x0123456789ABCDEFULL;
 
-      CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64>(value, 0U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64>(value, 1U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64>(value, 2U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64>(value, 3U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64>(value, 4U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64>(value, 5U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64>(value, 6U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64>(value, 7U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64>(value, 8U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64>(value, 9U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64>(value, 10U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64>(value, 11U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64>(value, 12U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64>(value, 13U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64>(value, 14U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64>(value, 15U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64>(value, 16U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64>(value, 17U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64>(value, 18U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64>(value, 19U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64>(value, 20U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64>(value, 21U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64>(value, 22U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64>(value, 23U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64>(value, 24U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64>(value, 25U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64>(value, 26U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64>(value, 27U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64>(value, 28U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64>(value, 29U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64>(value, 30U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64>(value, 31U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64>(value, 32U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64>(value, 33U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64>(value, 34U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64>(value, 35U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64>(value, 36U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64>(value, 37U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64>(value, 38U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64>(value, 39U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64>(value, 40U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64>(value, 41U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64>(value, 42U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64>(value, 43U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64>(value, 44U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64>(value, 45U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64>(value, 46U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64>(value, 47U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64>(value, 48U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64>(value, 49U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64>(value, 50U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64>(value, 51U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64>(value, 52U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64>(value, 53U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64>(value, 54U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64>(value, 55U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64>(value, 56U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64>(value, 57U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64>(value, 58U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64>(value, 59U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64>(value, 60U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64>(value, 61U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64>(value, 62U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64>(value, 63U).value<uint64_t>()));
-      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64>(value, 0U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64>(value, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64>(value, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64>(value, 3U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64>(value, 4U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64>(value, 5U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64>(value, 6U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64>(value, 7U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64>(value, 8U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64>(value, 9U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64>(value, 10U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64>(value, 11U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64>(value, 12U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64>(value, 13U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64>(value, 14U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64>(value, 15U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64>(value, 16U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64>(value, 17U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64>(value, 18U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64>(value, 19U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64>(value, 20U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64>(value, 21U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64>(value, 22U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64>(value, 23U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64>(value, 24U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64>(value, 25U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64>(value, 26U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64>(value, 27U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64>(value, 28U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64>(value, 29U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64>(value, 30U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64>(value, 31U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64>(value, 32U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64>(value, 33U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64>(value, 34U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64>(value, 35U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64>(value, 36U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64>(value, 37U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64>(value, 38U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64>(value, 39U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64>(value, 40U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64>(value, 41U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64>(value, 42U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64>(value, 43U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64>(value, 44U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64>(value, 45U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64>(value, 46U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64>(value, 47U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64>(value, 48U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64>(value, 49U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64>(value, 50U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64>(value, 51U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64>(value, 52U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64>(value, 53U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64>(value, 54U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64>(value, 55U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64>(value, 56U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64>(value, 57U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64>(value, 58U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64>(value, 59U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64>(value, 60U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64>(value, 61U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64>(value, 62U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64>(value, 63U).value<int64_t>()));
+      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_operator_all_shifts_partial_size)
     {
       uint64_t value = 0x0123456789ABCDEFULL;
-      uint64_t mask  = 0x0FFFFFFFFFFFFFFFULL;
+      uint64_t mask = 0x0FFFFFFFFFFFFFFFULL;
 
-      CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<60>(value, 0U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<60>(value, 1U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<60>(value, 2U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<60>(value, 3U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<60>(value, 4U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<60>(value, 5U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<60>(value, 6U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<60>(value, 7U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<60>(value, 8U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<60>(value, 9U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<60>(value, 10U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<60>(value, 11U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<60>(value, 12U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<60>(value, 13U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<60>(value, 14U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<60>(value, 15U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<60>(value, 16U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<60>(value, 17U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<60>(value, 18U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<60>(value, 19U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<60>(value, 20U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<60>(value, 21U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<60>(value, 22U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<60>(value, 23U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<60>(value, 24U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<60>(value, 25U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<60>(value, 26U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<60>(value, 27U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<60>(value, 28U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<60>(value, 29U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<60>(value, 30U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<60>(value, 31U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<60>(value, 32U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<60>(value, 33U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<60>(value, 34U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<60>(value, 35U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<60>(value, 36U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<60>(value, 37U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<60>(value, 38U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<60>(value, 39U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<60>(value, 40U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<60>(value, 41U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<60>(value, 42U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<60>(value, 43U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<60>(value, 44U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<60>(value, 45U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<60>(value, 46U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<60>(value, 47U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<60>(value, 48U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<60>(value, 49U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<60>(value, 50U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<60>(value, 51U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<60>(value, 52U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<60>(value, 53U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<60>(value, 54U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<60>(value, 55U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<60>(value, 56U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<60>(value, 57U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<60>(value, 58U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<60>(value, 59U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<60>(value, 60U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<60>(value, 61U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<60>(value, 62U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<60>(value, 63U).value<uint64_t>()));
-      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<60>(value, 64U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64>(value, 0U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64>(value, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64>(value, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64>(value, 3U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64>(value, 4U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64>(value, 5U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64>(value, 6U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64>(value, 7U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64>(value, 8U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64>(value, 9U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64>(value, 10U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64>(value, 11U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64>(value, 12U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64>(value, 13U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64>(value, 14U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64>(value, 15U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64>(value, 16U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64>(value, 17U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64>(value, 18U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64>(value, 19U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64>(value, 20U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64>(value, 21U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64>(value, 22U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64>(value, 23U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64>(value, 24U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64>(value, 25U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64>(value, 26U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64>(value, 27U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64>(value, 28U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64>(value, 29U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64>(value, 30U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64>(value, 31U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64>(value, 32U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64>(value, 33U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64>(value, 34U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64>(value, 35U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64>(value, 36U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64>(value, 37U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64>(value, 38U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64>(value, 39U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64>(value, 40U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64>(value, 41U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64>(value, 42U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64>(value, 43U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64>(value, 44U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64>(value, 45U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64>(value, 46U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64>(value, 47U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64>(value, 48U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64>(value, 49U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64>(value, 50U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64>(value, 51U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64>(value, 52U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64>(value, 53U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64>(value, 54U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64>(value, 55U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64>(value, 56U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64>(value, 57U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64>(value, 58U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64>(value, 59U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64>(value, 60U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64>(value, 61U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64>(value, 62U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64>(value, 63U).value<int64_t>()));
+      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_and_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data3(0x12345678UL & 0x23456789UL);
-      etl::bitset<60> data4(data1 & data2);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data4(0x12345678UL & 0x23456789UL);
+
+      ETL_CONSTEXPR14 etl::bitset<64> data3 = data1 & data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_and_equals_operator_helper(etl::bitset<64> data1, const etl::bitset<64>&data2)
+    {
+      data1 &= data2;
+
+      return data1;
+    }
+
     TEST(test_and_equals_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data3(0x12345678UL & 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
 
-      etl::bitset<60> data4(data1);
-      data4 &= data2;
-      CHECK(data3 == data4);
+      ETL_CONSTEXPR14 etl::bitset<64> data3(test_and_equals_operator_helper(data1, data2));
+
+      CHECK((data1 & data2) == data3);
     }
 
     //*************************************************************************
     TEST(test_or_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data4(0x12345678UL | 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data4(0x12345678UL | 0x23456789UL);
 
-      etl::bitset<60> data3(data1 | data2);
+      ETL_CONSTEXPR14 etl::bitset<64> data3 = data1 | data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_or_equals_operator_helper(etl::bitset<64> data1, const etl::bitset<64>&data2)
+    {
+      data1 |= data2;
+
+      return data1;
+    }
+
     TEST(test_or_equals_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data3(0x12345678UL | 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
 
-      etl::bitset<60> data4(data1);
-      data4 |= data2;
-      CHECK(data3 == data4);
+      ETL_CONSTEXPR14 etl::bitset<64> data3(test_or_equals_operator_helper(data1, data2));
+
+      CHECK((data1 | data2) == data3);
     }
 
     //*************************************************************************
     TEST(test_xor_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data4(0x12345678UL ^ 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data4(0x12345678UL ^ 0x23456789UL);
 
-      etl::bitset<60> data3(data1 ^ data2);
+      ETL_CONSTEXPR14 etl::bitset<64> data3 = data1 ^ data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_xor_equals_operator_helper(etl::bitset<64> data1, const etl::bitset<64>&data2)
+    {
+      data1 ^= data2;
+
+      return data1;
+    }
+
     TEST(test_xor_equals_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data3(0x12345678UL ^ 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
 
-      etl::bitset<60> data4(data1);
-      data4 ^= data2;
-      CHECK(data3 == data4);
+      ETL_CONSTEXPR14 etl::bitset<64> data3(test_xor_equals_operator_helper(data1, data2));
+
+      CHECK((data1 ^ data2) == data3);
     }
 
     //*************************************************************************
     TEST(test_find_first)
     {
-      ETL_CONSTEXPR14 etl::bitset<9> bs1(ull(0x0000));
-      ETL_CONSTEXPR14 size_t bs1fff = bs1.find_first(false);
-      ETL_CONSTEXPR14 size_t bs1fft = bs1.find_first(true);
-      CHECK_EQUAL(0U, bs1fff);
-      CHECK_EQUAL(etl::bitset<>::npos, bs1fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs1(ull(0x00));
+      ETL_CONSTEXPR14 size_t bs1find_first_false = bs1.find_first(false);
+      ETL_CONSTEXPR14 size_t bs1find_first_true = bs1.find_first(true);
+      CHECK_EQUAL(0U, bs1find_first_false);
+      CHECK_EQUAL(etl::bitset<>::npos, bs1find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs2(ull(0x01FF));
-      ETL_CONSTEXPR14 size_t bs2fff = bs2.find_first(false);
-      ETL_CONSTEXPR14 size_t bs2fft = bs2.find_first(true);
-      CHECK_EQUAL(etl::bitset<>::npos, bs2fff);
-      CHECK_EQUAL(0U, bs2fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs2(ull(0xFF));
+      ETL_CONSTEXPR14 size_t bs2find_first_false = bs2.find_first(false);
+      ETL_CONSTEXPR14 size_t bs2find_first_true = bs2.find_first(true);
+      CHECK_EQUAL(etl::bitset<>::npos, bs2find_first_false);
+      CHECK_EQUAL(0U, bs2find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs3(ull(0x0001));
-      ETL_CONSTEXPR14 size_t bs3fff = bs3.find_first(false);
-      ETL_CONSTEXPR14 size_t bs3fft = bs3.find_first(true);
-      CHECK_EQUAL(1U, bs3fff);
-      CHECK_EQUAL(0U, bs3fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs3(ull(0x01));
+      ETL_CONSTEXPR14 size_t bs3find_first_false = bs3.find_first(false);
+      ETL_CONSTEXPR14 size_t bs3find_first_true = bs3.find_first(true);
+      CHECK_EQUAL(1U, bs3find_first_false);
+      CHECK_EQUAL(0U, bs3find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs4(ull(0x0020));
-      ETL_CONSTEXPR14 size_t bs4fff = bs4.find_first(false);
-      ETL_CONSTEXPR14 size_t bs4fft = bs4.find_first(true);
-      CHECK_EQUAL(0U, bs4fff);
-      CHECK_EQUAL(5U, bs4fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs4(ull(0x20));
+      ETL_CONSTEXPR14 size_t bs4find_first_false = bs4.find_first(false);
+      ETL_CONSTEXPR14 size_t bs4find_first_true = bs4.find_first(true);
+      CHECK_EQUAL(0U, bs4find_first_false);
+      CHECK_EQUAL(5U, bs4find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs5(ull(0x0021));
-      ETL_CONSTEXPR14 size_t bs5fff = bs5.find_first(false);
-      ETL_CONSTEXPR14 size_t bs5fft = bs5.find_first(true);
-      CHECK_EQUAL(1U, bs5fff);
-      CHECK_EQUAL(0U, bs5fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs5(ull(0x21));
+      ETL_CONSTEXPR14 size_t bs5find_first_false = bs5.find_first(false);
+      ETL_CONSTEXPR14 size_t bs5find_first_true = bs5.find_first(true);
+      CHECK_EQUAL(1U, bs5find_first_false);
+      CHECK_EQUAL(0U, bs5find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs6(ull(0x000E));
-      ETL_CONSTEXPR14 size_t bs6fff = bs6.find_first(false);
-      ETL_CONSTEXPR14 size_t bs6fft = bs6.find_first(true);
-      CHECK_EQUAL(0U, bs6fff);
-      CHECK_EQUAL(1U, bs6fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs6(ull(0x0E));
+      ETL_CONSTEXPR14 size_t bs6find_first_false = bs6.find_first(false);
+      ETL_CONSTEXPR14 size_t bs6find_first_true = bs6.find_first(true);
+      CHECK_EQUAL(0U, bs6find_first_false);
+      CHECK_EQUAL(1U, bs6find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs7(ull(0x31));
-      ETL_CONSTEXPR14 size_t bs7fff = bs7.find_first(false);
-      ETL_CONSTEXPR14 size_t bs7fft = bs7.find_first(true);
-      CHECK_EQUAL(1U, bs7fff);
-      CHECK_EQUAL(0U, bs7fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs7(ull(0x31));
+      ETL_CONSTEXPR14 size_t bs7find_first_false = bs7.find_first(false);
+      ETL_CONSTEXPR14 size_t bs7find_first_true = bs7.find_first(true);
+      CHECK_EQUAL(1U, bs7find_first_false);
+      CHECK_EQUAL(0U, bs7find_first_true);
     }
-     
+
     //*************************************************************************
     TEST(test_find_next)
     {
-      ETL_CONSTEXPR14 etl::bitset<9> bs1(ull(0x0000));
-      ETL_CONSTEXPR14 size_t bs1fnf0 = bs1.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs1fnf1 = bs1.find_next(false, 1);
-      ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 2);
-      CHECK_EQUAL(0U, bs1fnf0);
-      CHECK_EQUAL(1U, bs1fnf1);
-      CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2);
+      ETL_CONSTEXPR14 etl::bitset<8> bs1(ull(0x00));
+      ETL_CONSTEXPR14 size_t bs1find_next_false0 = bs1.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs1find_next_false1 = bs1.find_next(false, 1);
+      ETL_CONSTEXPR14 size_t bs1find_next_true2 = bs1.find_next(true, 2);
+      CHECK_EQUAL(0U, bs1find_next_false0);
+      CHECK_EQUAL(1U, bs1find_next_false1);
+      CHECK_EQUAL(etl::bitset<>::npos, bs1find_next_true2);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs2(ull(0x1FF));
-      ETL_CONSTEXPR14 size_t bs2fnt0 = bs2.find_next(true, 0);
-      ETL_CONSTEXPR14 size_t bs2fnt1 = bs2.find_next(true, 1);
-      ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 2);
-      CHECK_EQUAL(0U, bs2fnt0);
-      CHECK_EQUAL(1U, bs2fnt1);
-      CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2);
+      ETL_CONSTEXPR14 etl::bitset<8> bs2(ull(0xFF));
+      ETL_CONSTEXPR14 size_t bs2find_next_true0 = bs2.find_next(true, 0);
+      ETL_CONSTEXPR14 size_t bs2find_next_true1 = bs2.find_next(true, 1);
+      ETL_CONSTEXPR14 size_t bs2find_next_false2 = bs2.find_next(false, 2);
+      CHECK_EQUAL(0U, bs2find_next_true0);
+      CHECK_EQUAL(1U, bs2find_next_true1);
+      CHECK_EQUAL(etl::bitset<>::npos, bs2find_next_false2);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs3(ull(0x000E));
-      ETL_CONSTEXPR14 size_t bs3fnf0 = bs3.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs3fnt1 = bs3.find_next(true, 1);
-      ETL_CONSTEXPR14 size_t bs3fnf2 = bs3.find_next(false, 2);
-      CHECK_EQUAL(0U, bs3fnf0);
-      CHECK_EQUAL(1U, bs3fnt1);
-      CHECK_EQUAL(4U, bs3fnf2);
+      ETL_CONSTEXPR14 etl::bitset<8> bs3(ull(0x0E));
+      ETL_CONSTEXPR14 size_t bs3find_next_false0 = bs3.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs3find_next_true1 = bs3.find_next(true, 1);
+      ETL_CONSTEXPR14 size_t bs3find_next_false2 = bs3.find_next(false, 2);
+      CHECK_EQUAL(0U, bs3find_next_false0);
+      CHECK_EQUAL(1U, bs3find_next_true1);
+      CHECK_EQUAL(4U, bs3find_next_false2);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs4(ull(0x0031));
-      ETL_CONSTEXPR14 size_t bs4fnt0 = bs4.find_next(true, 0);
-      ETL_CONSTEXPR14 size_t bs4fnf0 = bs4.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs4fnt1 = bs4.find_next(true, 1);
-      CHECK_EQUAL(0U, bs4fnt0);
-      CHECK_EQUAL(1U, bs4fnf0);
-      CHECK_EQUAL(4U, bs4fnt1);
+      ETL_CONSTEXPR14 etl::bitset<8> bs4(ull(0x31));
+      ETL_CONSTEXPR14 size_t bs4find_next_true0 = bs4.find_next(true, 0);
+      ETL_CONSTEXPR14 size_t bs4find_next_false0 = bs4.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs4find_next_true1 = bs4.find_next(true, 1);
+      CHECK_EQUAL(0U, bs4find_next_true0);
+      CHECK_EQUAL(1U, bs4find_next_false0);
+      CHECK_EQUAL(4U, bs4find_next_true1);
     }
 
     //*************************************************************************
-    TEST(test_find_next_github_issue_617)
+    ETL_CONSTEXPR14 std::pair<etl::bitset<8>, etl::bitset<8>> test_swap_helper()
     {
-      ETL_CONSTEXPR14 etl::bitset<64> bs1(ull(0xC000000000000031));
-      ETL_CONSTEXPR14 size_t bs1fnt1 = bs1.find_next(true, 10);
-      ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 59);
-      CHECK_EQUAL(62U, bs1fnt1);
-      CHECK_EQUAL(62U, bs1fnt2);
+      etl::bitset<8> data1(ull(0x2A));
+      etl::bitset<8> data2(ull(0x15));
 
-      ETL_CONSTEXPR14 etl::bitset<64> bs2(ull(0x3FFFFFFFFFFFFFCE));
-      ETL_CONSTEXPR14 size_t bs2fnf1 = bs2.find_next(false, 10);
-      ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 59);
-      CHECK_EQUAL(62U, bs2fnf1);
-      CHECK_EQUAL(62U, bs2fnf2);
+      swap(data1, data2);
 
-      ETL_CONSTEXPR14 etl::bitset<64, uint32_t> bs32(ull(0xC000000000000031));
-      ETL_CONSTEXPR14 size_t bs32fnt1 = bs32.find_next(true, 10);
-      ETL_CONSTEXPR14 size_t bs32fnt2 = bs32.find_next(true, 59);
-      CHECK_EQUAL(62U, bs32fnt1);
-      CHECK_EQUAL(62U, bs32fnt2);
+      return std::pair<etl::bitset<8>, etl::bitset<8>>(data1, data2);
     }
 
-    //*************************************************************************
-    //*************************************************************************
     TEST(test_swap)
     {
-      etl::bitset<9> compare1(0x2A);
-      etl::bitset<9> compare2(0x15);
-      etl::bitset<9> compare1a(0x2A);
-      etl::bitset<9> compare2a(0x15);
+      ETL_CONSTEXPR14 etl::bitset<8> compare1(0x2A);
+      ETL_CONSTEXPR14 etl::bitset<8> compare2(0x15);
 
-      swap(compare1a, compare2a);
+      ETL_CONSTEXPR14 std::pair<etl::bitset<8>, etl::bitset<8>> swapped = test_swap_helper();
 
-      CHECK(compare1 == compare2a);
-      CHECK(compare2 == compare1a);
+      CHECK(swapped.first == compare2);
+      CHECK(swapped.second == compare1);
     }
 
     //*************************************************************************
@@ -2170,10 +1690,25 @@ namespace
       etl::bitset<32> b(0x12345678UL);
 
       span_t s = b.span();
-      CHECK_EQUAL(0x78U, s[0]);
-      CHECK_EQUAL(0x56U, s[1]);
-      CHECK_EQUAL(0x34U, s[2]);
-      CHECK_EQUAL(0x12U, s[3]);
+
+      if (etl::endianness::value() == etl::endian::little)
+      {
+        CHECK_EQUAL(0x78UL, s[0]);
+        CHECK_EQUAL(0x56UL, s[1]);
+        CHECK_EQUAL(0x34UL, s[2]);
+        CHECK_EQUAL(0x12UL, s[3]);
+      }
+      else
+      {
+        CHECK_EQUAL(0x78UL, s[3]);
+        CHECK_EQUAL(0x56UL, s[2]);
+        CHECK_EQUAL(0x34UL, s[1]);
+        CHECK_EQUAL(0x12UL, s[0]);
+      }
+
+      s[2] = 0x9AU;
+      uint32_t value = b.value<uint32_t>();
+      CHECK_EQUAL(0x129A5678UL, value);
     }
 
     //*************************************************************************
@@ -2184,28 +1719,44 @@ namespace
       const etl::bitset<32> b(0x12345678UL);
 
       span_t s = b.span();
-      CHECK_EQUAL(0x78U, s[0]);
-      CHECK_EQUAL(0x56U, s[1]);
-      CHECK_EQUAL(0x34U, s[2]);
-      CHECK_EQUAL(0x12U, s[3]);
+
+      if (etl::endianness::value() == etl::endian::little)
+      {
+        CHECK_EQUAL(0x78UL, s[0]);
+        CHECK_EQUAL(0x56UL, s[1]);
+        CHECK_EQUAL(0x34UL, s[2]);
+        CHECK_EQUAL(0x12UL, s[3]);
+      }
+      else
+      {
+        CHECK_EQUAL(0x78UL, s[3]);
+        CHECK_EQUAL(0x56UL, s[2]);
+        CHECK_EQUAL(0x34UL, s[1]);
+        CHECK_EQUAL(0x12UL, s[0]);
+      }
     }
 
     //*************************************************************************
     TEST(test_to_string)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+      using bs32 = etl::bitset<32>;
+
+      ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
       etl::string<32> text = b.to_string('.', '*');
-      std::string stdtext  = b.to_string<std::string>('.', '*');
+      std::string stdtext = b.to_string<std::string>('.', '*');
 
-      CHECK_EQUAL("...*..*...**.*...*.*.**..****...", text.c_str());
-      CHECK_EQUAL("...*..*...**.*...*.*.**..****...", stdtext.c_str());
+      //CHECK_THROW(b.to_string<etl::string<30>>('.', '*'), etl::bitset_overflow);
+      CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(text.c_str()));
+      CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(stdtext.c_str()));
     }
 
     //*************************************************************************
     TEST(test_to_wstring)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+      using bs32 = etl::bitset<32>;
+
+      ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
       etl::wstring<32> text = b.to_string<etl::wstring<32>>(L'.', L'*');
       std::wstring stdtext = b.to_string<std::wstring>(L'.', L'*');
@@ -2217,7 +1768,9 @@ namespace
     //*************************************************************************
     TEST(test_to_u16string)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+      using bs32 = etl::bitset<32>;
+
+      ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
       etl::u16string<32> text = b.to_string<etl::u16string<32>>(u'.', u'*');
       std::u16string stdtext = b.to_string<std::u16string>(u'.', u'*');
@@ -2229,7 +1782,9 @@ namespace
     //*************************************************************************
     TEST(test_to_u32string)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+      using bs32 = etl::bitset<32>;
+
+      ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
       etl::u32string<32> text = b.to_string<etl::u32string<32>>(U'.', U'*');
       std::u32string stdtext = b.to_string<std::u32string>(U'.', U'*');
@@ -2238,21 +1793,21 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
 
-    //*************************************************************************
+    ////*************************************************************************
     TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>(0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>(1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>(2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>(3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>(4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>(5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>(6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>(7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>(8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>(9, 6)));
       CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
       CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
       CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
@@ -2280,16 +1835,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t, 9, 6>()));
       CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
       CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
       CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
@@ -2318,16 +1873,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
       CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
       CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
@@ -2355,16 +1910,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
@@ -2393,16 +1948,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
-      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
-      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
-      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>(0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>(1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>(2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>(3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>(4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>(5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>(6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>(7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>(8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>(9, 8));
       CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
       CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
       CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
@@ -2418,7 +1973,7 @@ namespace
       CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
       CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
       CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
-      
+
       CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
       CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
@@ -2428,16 +1983,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t, 0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t, 1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t, 2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t, 3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t, 4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t, 5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t, 6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t, 7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t, 8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t, 9, 8>()));
       CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
       CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
       CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
@@ -2464,16 +2019,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
-      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
-      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
-      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
-      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
-      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
-      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
-      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
-      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
-      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>(0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>(1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>(2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>(3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>(4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>(5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>(6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>(7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>(8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>(9, 8));
       CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
       CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
       CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
@@ -2499,16 +2054,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t, 0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t, 1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t, 2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t, 3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t, 4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t, 5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t, 6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t, 7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t, 8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t, 9, 8>()));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
       CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
       CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
@@ -2535,16 +2090,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>(0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>(1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>(2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>(3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>(4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>(5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>(6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>(7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>(8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>(9, 13));
       CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
       CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
       CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
@@ -2565,26 +2120,26 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18,13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19,13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t, 0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t, 1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t, 2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t, 3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t, 4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t, 5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t, 6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t, 7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t, 8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t, 9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
 
       // The lines below should static assert.
       //uint16_t v1 = b.extract<uint16_t, 19, 14);
@@ -2596,16 +2151,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
-      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
-      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>(0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>(1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>(2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>(3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>(4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>(5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>(6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>(7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>(8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>(9, 16));
       CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
       CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
       CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
@@ -2623,16 +2178,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t, 0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t, 1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t, 2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t, 3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t, 4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t, 5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t, 6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t, 7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t, 8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t, 9, 16>()));
       CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
       CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
       CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
@@ -2651,16 +2206,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
-      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
-      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
-      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
-      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
-      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
-      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
-      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
-      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
-      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>(0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>(1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>(2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>(3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>(4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>(5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>(6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>(7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>(8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>(9, 16));
       CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
       CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
       CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
@@ -2678,16 +2233,16 @@ namespace
     {
       ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
 
-      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t, 0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t, 1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t, 2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t, 3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t, 4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t, 5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t, 6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t, 7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t, 8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t, 9, 16>()));
       CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
       CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
       CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index 18d19157..0ce70049 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -117,7 +117,7 @@ namespace
     return data2;
   }
 
-  SUITE(test_bitset_new_implicit_element_type)
+  SUITE(test_bitset_new_explicit_element_type)
   {
     //*************************************************************************
     TEST(test_default_constructor)
@@ -142,15 +142,20 @@ namespace
       etl::bitset<32, uint32_t> data32;
       etl::bitset<64, uint64_t> data64;
 
+      CHECK_EQUAL(8,  data8.Size);
+      CHECK_EQUAL(16, data16.Size);
+      CHECK_EQUAL(32, data32.Size);
+      CHECK_EQUAL(64, data64.Size);
+
       CHECK_EQUAL(1U, data8.Number_Of_Elements);
       CHECK_EQUAL(1U, data16.Number_Of_Elements);
       CHECK_EQUAL(1U, data32.Number_Of_Elements);
       CHECK_EQUAL(1U, data64.Number_Of_Elements);
 
-      CHECK_EQUAL(etl::bitset_layout::Single, data8.Element_Layout);
-      CHECK_EQUAL(etl::bitset_layout::Single, data16.Element_Layout);
-      CHECK_EQUAL(etl::bitset_layout::Single, data32.Element_Layout);
-      CHECK_EQUAL(etl::bitset_layout::Single, data64.Element_Layout);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data8.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data16.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data32.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data64.Storage_Model);
     }
 
     //*************************************************************************
@@ -554,7 +559,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char16_t_6string)
+    TEST(test_from_string_with_char16_t)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
       etl::bitset<64, uint64_t> data;
@@ -1808,6 +1813,9 @@ namespace
 
       span_t s = b.span();
       CHECK_EQUAL(0x12345678UL, s[0]);
+
+      s[0] = 0x87654321UL;
+      CHECK_EQUAL(0x87654321UL, b.value<uint32_t>());
     }
 
     //*************************************************************************
diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp
index 7cd47788..d62d5c42 100644
--- a/test/test_bitset_new_ext_default_element_type.cpp
+++ b/test/test_bitset_new_ext_default_element_type.cpp
@@ -37,6 +37,7 @@ SOFTWARE.
 #include "etl/wstring.h"
 #include "etl/u16string.h"
 #include "etl/u32string.h"
+#include "etl/endianness.h"
 
 namespace
 {
@@ -44,729 +45,6 @@ namespace
 
   SUITE(test_bitset_new_ext_default_element_type)
   {
-    //*************************************************************************
-    TEST(test_default_constructor)
-    {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
-
-      CHECK_EQUAL(compare.size(),  data.size());
-      CHECK_EQUAL(compare.count(), data.count());
-
-      for (size_t i = 0UL; i < data.size(); ++i)
-      {
-        CHECK_EQUAL(compare.test(i), data.test(i));
-      }
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_multi_element)
-    {
-      etl::bitset_ext<14, int8_t>::buffer_type buffer14;
-      etl::bitset_ext<30, int16_t>::buffer_type buffer30;
-      etl::bitset_ext<62, int32_t>::buffer_type buffer62;
-
-      etl::bitset_ext<14, int8_t>  data8(buffer14);
-      etl::bitset_ext<30, int16_t> data16(buffer30);
-      etl::bitset_ext<62, int32_t> data32(buffer62);
-
-      CHECK_EQUAL(2U, data8.Number_Of_Elements);
-      CHECK_EQUAL(2U, data16.Number_Of_Elements);
-      CHECK_EQUAL(2U, data32.Number_Of_Elements);
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_default_element_type_bits)
-    {
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<1>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<2>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<3>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<4>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<5>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<6>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<7>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<8>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<9>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<10>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<11>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<12>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<13>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<14>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<15>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<16>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<17>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<18>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<19>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<20>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<21>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<22>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<23>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<24>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<25>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<26>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<27>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<28>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<29>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<30>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<31>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<32>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<33>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<34>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<35>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<36>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<37>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<38>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<39>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<40>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<41>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<42>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<43>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<44>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<45>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<46>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<47>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<48>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<49>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<50>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<51>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<52>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<53>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<54>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<55>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<56>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<57>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<58>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<59>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<60>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<61>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<62>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<63>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<64>::element_type>::bits);
-    }
-     
-    //*************************************************************************
-    TEST(test_default_constructor_default_element_type_number_of_elements)
-    {
-      CHECK_EQUAL(1U, etl::bitset_ext<1>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<2>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<3>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<4>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<5>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<6>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<7>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<8>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<9>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<10>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<11>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<12>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<13>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<14>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<15>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<16>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<17>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<18>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<19>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<20>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<21>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<22>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<23>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<24>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<25>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<26>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<27>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<28>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<29>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<30>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<31>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<32>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<33>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<34>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<35>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<36>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<37>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<38>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<39>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<40>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<41>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<42>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<43>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<44>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<45>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<46>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<47>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<48>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<49>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<50>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<51>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<52>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<53>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<54>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<55>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<56>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<57>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<58>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<59>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<60>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<61>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<62>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<63>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<64>::Number_Of_Elements);
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int8_t_element_types_bits)
-    {
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<1, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<2, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<3, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<4, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<5, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<6, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<7, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<8, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<9, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<10, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<11, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<12, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<13, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<14, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<15, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<16, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<17, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<18, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<19, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<20, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<21, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<22, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<23, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<24, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<25, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<26, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<27, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<28, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<29, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<30, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<31, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<32, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<33, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<34, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<35, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<36, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<37, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<38, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<39, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<40, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<41, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<42, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<43, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<44, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<45, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<46, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<47, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<48, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<49, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<50, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<51, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<52, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<53, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<54, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<55, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<56, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<57, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<58, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<59, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<60, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<61, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<62, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<63, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<64, int8_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int8_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset_ext<1, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<2, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<3, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<4, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<5, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<6, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<7, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<8, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<9, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<10, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<11, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<12, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<13, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<14, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<15, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<16, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<17, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<18, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<19, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<20, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<21, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<22, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<23, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<24, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<25, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<26, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<27, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<28, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<29, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<30, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<31, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<32, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<33, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<34, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<35, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<36, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<37, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<38, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<39, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<40, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<41, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<42, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<43, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<44, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<45, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<46, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<47, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<48, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<49, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<50, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<51, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<52, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<53, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<54, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<55, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<56, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<57, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<58, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<59, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<60, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<61, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<62, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<63, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<64, int8_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int16_t_element_types_bits)
-    {
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<1, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<2, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<3, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<4, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<5, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<6, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<7, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<8, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<9, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<10, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<11, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<12, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<13, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<14, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<15, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<16, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<17, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<18, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<19, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<20, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<21, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<22, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<23, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<24, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<25, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<26, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<27, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<28, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<29, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<30, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<31, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<32, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<33, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<34, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<35, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<36, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<37, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<38, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<39, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<40, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<41, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<42, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<43, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<44, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<45, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<46, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<47, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<48, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<49, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<50, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<51, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<52, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<53, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<54, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<55, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<56, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<57, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<58, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<59, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<60, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<61, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<62, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<63, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<64, int16_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int16_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset_ext<1, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<2, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<3, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<4, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<5, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<6, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<7, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<8, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<9, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<10, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<11, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<12, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<13, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<14, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<15, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<16, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<17, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<18, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<19, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<20, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<21, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<22, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<23, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<24, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<25, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<26, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<27, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<28, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<29, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<30, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<31, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<32, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<33, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<34, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<35, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<36, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<37, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<38, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<39, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<40, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<41, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<42, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<43, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<44, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<45, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<46, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<47, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<48, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<49, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<50, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<51, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<52, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<53, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<54, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<55, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<56, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<57, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<58, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<59, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<60, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<61, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<62, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<63, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<64, int16_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int32_t_element_types_bits)
-    {
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<1, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<2, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<3, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<4, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<5, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<6, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<7, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<8, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<9, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<10, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<11, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<12, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<13, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<14, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<15, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<16, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<17, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<18, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<19, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<20, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<21, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<22, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<23, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<24, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<25, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<26, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<27, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<28, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<29, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<30, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<31, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<32, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<33, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<34, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<35, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<36, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<37, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<38, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<39, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<40, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<41, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<42, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<43, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<44, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<45, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<46, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<47, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<48, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<49, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<50, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<51, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<52, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<53, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<54, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<55, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<56, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<57, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<58, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<59, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<60, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<61, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<62, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<63, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<64, int32_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int32_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset_ext<1, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<2, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<3, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<4, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<5, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<6, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<7, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<8, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<9, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<10, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<11, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<12, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<13, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<14, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<15, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<16, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<17, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<18, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<19, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<20, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<21, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<22, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<23, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<24, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<25, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<26, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<27, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<28, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<29, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<30, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<31, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<32, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<33, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<34, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<35, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<36, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<37, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<38, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<39, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<40, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<41, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<42, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<43, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<44, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<45, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<46, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<47, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<48, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<49, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<50, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<51, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<52, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<53, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<54, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<55, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<56, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<57, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<58, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<59, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<60, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<61, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<62, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<63, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<64, int32_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int64_t_element_types_bits)
-    {
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<1, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<2, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<3, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<4, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<5, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<6, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<7, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<8, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<9, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<10, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<11, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<12, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<13, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<14, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<15, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<16, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<17, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<18, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<19, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<20, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<21, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<22, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<23, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<24, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<25, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<26, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<27, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<28, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<29, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<30, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<31, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<32, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<33, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<34, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<35, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<36, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<37, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<38, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<39, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<40, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<41, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<42, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<43, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<44, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<45, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<46, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<47, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<48, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<49, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<50, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<51, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<52, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<53, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<54, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<55, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<56, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<57, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<58, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<59, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<60, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<61, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<62, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<63, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<64, int64_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int64_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset_ext<1, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<2, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<3, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<4, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<5, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<6, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<7, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<8, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<9, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<10, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<11, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<12, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<13, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<14, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<15, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<16, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<17, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<18, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<19, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<20, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<21, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<22, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<23, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<24, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<25, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<26, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<27, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<28, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<29, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<30, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<31, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<32, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<33, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<34, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<35, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<36, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<37, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<38, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<39, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<40, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<41, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<42, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<43, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<44, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<45, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<46, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<47, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<48, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<49, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<50, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<51, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<52, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<53, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<54, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<55, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<56, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<57, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<58, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<59, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<60, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<61, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<62, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<63, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<64, int64_t>::Number_Of_Elements));
-    }
-
     //*************************************************************************
     TEST(test_construct_from_nullptr_buffer)
     {
@@ -777,23 +55,55 @@ namespace
 
       CHECK_THROW(BsExt bs1(nullptr), etl::bitset_invalid_buffer);
       CHECK_THROW(BsExt bs2b(bs2a, nullptr), etl::bitset_invalid_buffer);
-      CHECK_THROW(BsExt bs3(0ULL,  nullptr), etl::bitset_invalid_buffer);
-      CHECK_THROW(BsExt bs4("0",   nullptr), etl::bitset_invalid_buffer);
-      CHECK_THROW(BsExt bs5(L"0",  nullptr), etl::bitset_invalid_buffer);
-      CHECK_THROW(BsExt bs6(u"0",  nullptr), etl::bitset_invalid_buffer);
-      CHECK_THROW(BsExt bs7(U"0",  nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs3(0ULL, nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs4("0", nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs5(L"0", nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs6(u"0", nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs7(U"0", nullptr), etl::bitset_invalid_buffer);
+    }
+
+    //*************************************************************************
+    TEST(test_default_constructor_from_array)
+    {
+      etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements];
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
+
+      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.count(), data.count());
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_default_constructor_from_buffer_type)
+    {
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
+
+      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.count(), data.count());
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
     }
 
     //*************************************************************************
     TEST(test_construct_from_value)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<64>::buffer_type buffer1;
+      std::bitset<64> compare(0x123456731234567ULL);
+      etl::bitset_ext<64> data(0x123456731234567ULL, buffer1);
 
-      std::bitset<60> compare(0x123456731234567ULL);
-      etl::bitset_ext<60> data(0x123456731234567ULL, buffer);
-
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
+      CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -804,12 +114,11 @@ namespace
     //*************************************************************************
     TEST(test_copy_construct)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-
-      std::bitset<60> compare(0x123456731234567ULL);
-      etl::bitset_ext<60> data(0x123456731234567ULL, buffer1);
-      etl::bitset_ext<60> data_copy(data, buffer2);
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      std::bitset<64> compare(0x123456731234567ULL);
+      etl::bitset_ext<64> data(0x123456731234567ULL, buffer1);
+      etl::bitset_ext<64> data_copy(data, buffer2);
 
       CHECK_EQUAL(compare.size(), data_copy.size());
       CHECK_EQUAL(compare.count(), data_copy.count());
@@ -823,12 +132,11 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_excess_value)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(0x8765432187654321ULL);
+      etl::bitset_ext<64> data(0x8765432187654321ULL, buffer);
 
-      std::bitset<60> compare(0x8765432187654321ULL);
-      etl::bitset_ext<60> data(0x8765432187654321ULL, buffer);
-
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -840,12 +148,11 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data("110001001000110100010101100111001100010010001101000101011001", buffer);
 
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data("110001001000110100010101100111001100010010001101000101011001", buffer);
-
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -857,10 +164,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_wchar_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(L"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(L"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -874,10 +180,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char16_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(u"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(u"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -891,10 +196,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char32_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(U"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(U"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -908,10 +212,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_nullptr_char_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
       const char* s = nullptr;
 
+      etl::bitset_ext<60>::buffer_type buffer;
       etl::bitset_ext<60> data(s, buffer);
 
       CHECK_EQUAL(60, data.size());
@@ -921,10 +224,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_nullptr_wchar_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
       const wchar_t* s = nullptr;
 
+      etl::bitset_ext<60>::buffer_type buffer;
       etl::bitset_ext<60> data(s, buffer);
 
       CHECK_EQUAL(60, data.size());
@@ -934,10 +236,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_nullptr_char16_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
       const char16_t* s = nullptr;
 
+      etl::bitset_ext<60>::buffer_type buffer;
       etl::bitset_ext<60> data(s, buffer);
 
       CHECK_EQUAL(60, data.size());
@@ -947,10 +248,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_nullptr_char32_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
       const char32_t* s = nullptr;
 
+      etl::bitset_ext<60>::buffer_type buffer;
       etl::bitset_ext<60> data(s, buffer);
 
       CHECK_EQUAL(60, data.size());
@@ -960,16 +260,17 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_excess_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001");
+      etl::bitset_ext<64> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer);
 
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001111100001");
-      etl::bitset_ext<60> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer);
-
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(),  data.none());
-      CHECK_EQUAL(compare.any(),   data.any());
-      CHECK_EQUAL(compare.all(),   data.all());
+      CHECK_EQUAL(compare.none(), data.none());
+      CHECK_EQUAL(compare.any(), data.any());
+      CHECK_EQUAL(compare.all(), data.all());
+
+      CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -977,22 +278,55 @@ namespace
       }
     }
 
-    //*************************************************************************    
+    //*************************************************************************
     TEST(test_set)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
+      compare.set();
+      data.set();
+
+      auto size = data.size();
+      auto count = data.count();
+      auto none = data.none();
+      auto any = data.any();
+      auto all = data.all();
+
+      CHECK_EQUAL(compare.size(), size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(), none);
+      CHECK_EQUAL(compare.any(), any);
+      CHECK_EQUAL(compare.all(), all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_less_than_full_size)
+    {
+      etl::bitset_ext<60>::buffer_type buffer;
       std::bitset<60> compare;
       etl::bitset_ext<60> data(buffer);
 
       compare.set();
       data.set();
 
-      CHECK_EQUAL(compare.size(),  data.size());
-      CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(),  data.none());
-      CHECK_EQUAL(compare.any(),   data.any());
-      CHECK_EQUAL(compare.all(),   data.all());
+      auto size = data.size();
+      auto count = data.count();
+      auto none = data.none();
+      auto any = data.any();
+      auto all = data.all();
+
+      CHECK_EQUAL(compare.size(), size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(), none);
+      CHECK_EQUAL(compare.any(), any);
+      CHECK_EQUAL(compare.all(), all);
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1003,18 +337,17 @@ namespace
     //*************************************************************************
     TEST(test_set_with_char_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.set("110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(),  data.none());
-      CHECK_EQUAL(compare.any(),   data.any());
-      CHECK_EQUAL(compare.all(),   data.all());
+      CHECK_EQUAL(compare.none(), data.none());
+      CHECK_EQUAL(compare.any(), data.any());
+      CHECK_EQUAL(compare.all(), data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1025,10 +358,9 @@ namespace
     //*************************************************************************
     TEST(test_set_with_wchar_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.set(L"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1047,10 +379,9 @@ namespace
     //*************************************************************************
     TEST(test_set_with_char16_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.set(u"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1069,10 +400,9 @@ namespace
     //*************************************************************************
     TEST(test_set_with_char32_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.set(U"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1093,11 +423,11 @@ namespace
     {
       const char* s = nullptr;
 
-      etl::bitset_ext<60>::buffer_type buffer;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
       data.set(s);
 
-      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(64, data.size());
       CHECK_EQUAL(0, data.count());
     }
 
@@ -1106,11 +436,11 @@ namespace
     {
       const wchar_t* s = nullptr;
 
-      etl::bitset_ext<60>::buffer_type buffer;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
       data.set(s);
 
-      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(64, data.size());
       CHECK_EQUAL(0, data.count());
     }
 
@@ -1119,11 +449,11 @@ namespace
     {
       const char16_t* s = nullptr;
 
-      etl::bitset_ext<60>::buffer_type buffer;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
       data.set(s);
 
-      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(64, data.size());
       CHECK_EQUAL(0, data.count());
     }
 
@@ -1132,21 +462,20 @@ namespace
     {
       const char32_t* s = nullptr;
 
-      etl::bitset_ext<60>::buffer_type buffer;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
       data.set(s);
 
-      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(64, data.size());
       CHECK_EQUAL(0, data.count());
     }
 
     //*************************************************************************
     TEST(test_from_string_with_char)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.from_string("110001001000110100010101100111001100010010001101000101011001");
 
@@ -1165,10 +494,9 @@ namespace
     //*************************************************************************
     TEST(test_from_string_with_wchar_t)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.from_string(L"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1185,12 +513,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char16_t_6string)
+    TEST(test_from_string_with_char16_t)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.from_string(u"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1209,10 +536,9 @@ namespace
     //*************************************************************************
     TEST(test_from_string_with_char32_t)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.from_string(U"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1280,11 +606,50 @@ namespace
       CHECK_EQUAL(0, data.count());
     }
 
+    //*************************************************************************
+    TEST(test_value_u8_min)
+    {
+      etl::bitset_ext<8>::buffer_type buffer;
+      etl::bitset_ext<8> data((unsigned long long)etl::integral_limits<uint8_t>::min, buffer);
+      uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_u8_max)
+    {
+      etl::bitset_ext<8>::buffer_type buffer;
+      etl::bitset_ext<8> data((unsigned long long)etl::integral_limits<uint8_t>::max, buffer);
+      uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_s8_min)
+    {
+      etl::bitset_ext<8>::buffer_type buffer;
+      etl::bitset_ext<8> data((unsigned long long)etl::integral_limits<uint8_t>::min, buffer);
+      uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_s8_max)
+    {
+      etl::bitset_ext<8>::buffer_type buffer;
+      etl::bitset_ext<8> data((unsigned long long)etl::integral_limits<uint8_t>::max, buffer);
+      uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::max(), value);
+    }
+
     //*************************************************************************
     TEST(test_value_u16_min)
     {
       etl::bitset_ext<16>::buffer_type buffer;
-
       etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<uint16_t>::min, buffer);
       uint16_t value = data.value<uint16_t>();
 
@@ -1295,7 +660,6 @@ namespace
     TEST(test_value_u16_max)
     {
       etl::bitset_ext<16>::buffer_type buffer;
-
       etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<uint16_t>::max, buffer);
       uint16_t value = data.value<uint16_t>();
 
@@ -1306,29 +670,26 @@ namespace
     TEST(test_value_s16_min)
     {
       etl::bitset_ext<16>::buffer_type buffer;
+      etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<uint16_t>::min, buffer);
+      uint16_t value = data.value<uint16_t>();
 
-      etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<int16_t>::min, buffer);
-      int16_t value = data.value<int16_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int16_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint16_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s16_max)
     {
       etl::bitset_ext<16>::buffer_type buffer;
+      etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<uint16_t>::max, buffer);
+      uint16_t value = data.value<uint16_t>();
 
-      etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<int16_t>::max, buffer);
-      int16_t value = data.value<int16_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int16_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint16_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u32_min)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
-
+      etl::bitset_ext<32>::buffer_type buffer;
       etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<uint32_t>::min, buffer);
       uint32_t value = data.value<uint32_t>();
 
@@ -1338,8 +699,7 @@ namespace
     //*************************************************************************
     TEST(test_value_u32_max)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
-
+      etl::bitset_ext<32>::buffer_type buffer;
       etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<uint32_t>::max, buffer);
       uint32_t value = data.value<uint32_t>();
 
@@ -1349,30 +709,27 @@ namespace
     //*************************************************************************
     TEST(test_value_s32_min)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      etl::bitset_ext<32>::buffer_type buffer;
+      etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<uint32_t>::min, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<int32_t>::min, buffer);
-      int32_t value = data.value<int32_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int32_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s32_max)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      etl::bitset_ext<32>::buffer_type buffer;
+      etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<uint32_t>::max, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<int32_t>::max, buffer);
-      int32_t value = data.value<int32_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int32_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u64_min)
     {
-      etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements];
-
+      etl::bitset_ext<64>::buffer_type buffer;
       etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<uint64_t>::min, buffer);
       uint64_t value = data.value<uint64_t>();
 
@@ -1382,8 +739,7 @@ namespace
     //*************************************************************************
     TEST(test_value_u64_max)
     {
-      etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements];
-
+      etl::bitset_ext<64>::buffer_type buffer;
       etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<uint64_t>::max, buffer);
       uint64_t value = data.value<uint64_t>();
 
@@ -1393,32 +749,29 @@ namespace
     //*************************************************************************
     TEST(test_value_s64_min)
     {
-      etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements];
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<uint64_t>::min, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<int64_t>::min, buffer);
-      int64_t value = data.value<int64_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s64_max)
     {
-      etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements];
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<uint64_t>::max, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<int64_t>::max, buffer);
-      int64_t value = data.value<int64_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_position_set)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1450,19 +803,18 @@ namespace
     //*************************************************************************
     TEST(test_reset)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<60> data(0xFFFFFFFFFFFFFFFULL, buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      etl::bitset_ext<64> data(0xFFFFFFFFFFFFFFFULL, buffer);
 
       compare.reset();
       data.reset();
-      
-      CHECK_EQUAL(compare.size(),  data.size());
+
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(),  data.none());
-      CHECK_EQUAL(compare.any(),   data.any());
-      CHECK_EQUAL(compare.all(),   data.all());
+      CHECK_EQUAL(compare.none(), data.none());
+      CHECK_EQUAL(compare.any(), data.any());
+      CHECK_EQUAL(compare.all(), data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1473,10 +825,9 @@ namespace
     //*************************************************************************
     TEST(test_position_reset)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<60> data(0xFFFFFFFFFFFFFFFULL, buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      etl::bitset_ext<64> data(0xFFFFFFFFFFFFFFFULL, buffer);
 
       compare.reset(1);
       compare.reset(3);
@@ -1488,11 +839,11 @@ namespace
       data.reset(7);
       data.reset(13);
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(),  data.none());
-      CHECK_EQUAL(compare.any(),   data.any());
-      CHECK_EQUAL(compare.all(),   data.all());
+      CHECK_EQUAL(compare.none(), data.none());
+      CHECK_EQUAL(compare.any(), data.any());
+      CHECK_EQUAL(compare.all(), data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1530,10 +881,9 @@ namespace
     //*************************************************************************
     TEST(test_index_operator_read)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(0x3123456731234567ULL);
-      etl::bitset_ext<60> data(0x3123456731234567ULL, buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(0x3123456731234567ULL);
+      etl::bitset_ext<64> data(0x3123456731234567ULL, buffer);
 
       bool bc0 = compare[1U];
       bool bd0 = data[1U];
@@ -1555,8 +905,8 @@ namespace
     //*************************************************************************
     TEST(test_index_operator_write)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
 
       data[1U] = true;
       data[3U] = true;
@@ -1572,15 +922,14 @@ namespace
     //*************************************************************************
     TEST(test_any)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-      etl::bitset_ext<60>::buffer_type buffer4;
-
-      etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<60> data3(ull(0x0000010001000100), buffer3);
-      etl::bitset_ext<60> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.any();
       bool bd2 = data2.any();
@@ -1596,15 +945,14 @@ namespace
     //*************************************************************************
     TEST(test_none)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-      etl::bitset_ext<60>::buffer_type buffer4;
-
-      etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<60> data3(ull(0x0000010001000100), buffer3);
-      etl::bitset_ext<60> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.none();
       bool bd2 = data2.none();
@@ -1619,16 +967,84 @@ namespace
 
     //*************************************************************************
     TEST(test_all)
+    {
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.all();
+      bool bd2 = data2.all();
+      bool bd3 = data3.all();
+      bool bd4 = data4.all();
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_any_with_reduced_active_bits)
     {
       etl::bitset_ext<60>::buffer_type buffer1;
       etl::bitset_ext<60>::buffer_type buffer2;
       etl::bitset_ext<60>::buffer_type buffer3;
       etl::bitset_ext<60>::buffer_type buffer4;
-
       etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1);
       etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<60> data3(ull(0x0000010001000100), buffer3);
-      etl::bitset_ext<60> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<60> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.any();
+      bool bd2 = data2.any();
+      bool bd3 = data3.any();
+      bool bd4 = data4.any();
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60>::buffer_type buffer1;
+      etl::bitset_ext<60>::buffer_type buffer2;
+      etl::bitset_ext<60>::buffer_type buffer3;
+      etl::bitset_ext<60>::buffer_type buffer4;
+      etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.none();
+      bool bd2 = data2.none();
+      bool bd3 = data3.none();
+      bool bd4 = data4.none();
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60>::buffer_type buffer1;
+      etl::bitset_ext<60>::buffer_type buffer2;
+      etl::bitset_ext<60>::buffer_type buffer3;
+      etl::bitset_ext<60>::buffer_type buffer4;
+      etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.all();
       bool bd2 = data2.all();
@@ -1644,9 +1060,9 @@ namespace
     //*************************************************************************
     TEST(test_flip)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
       compare.flip();
       data.flip();
@@ -1657,12 +1073,12 @@ namespace
       }
     }
 
-    //*************************************************************************   
+    //*************************************************************************
     TEST(test_flip_position)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
       compare.flip(1);
       compare.flip(3);
@@ -1683,9 +1099,9 @@ namespace
     //*************************************************************************
     TEST(test_flip_reference)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
       compare[1].flip();
       compare[3].flip();
@@ -1706,10 +1122,9 @@ namespace
     //*************************************************************************
     TEST(test_invert_reference)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
       bool bc = ~compare[3];
       bool bd = ~data[3];
@@ -1717,19 +1132,18 @@ namespace
     }
 
     //*************************************************************************
-    void test_assignment_operator_helper(etl::bitset_ext<60>& from, etl::bitset_ext<60>& to)
+    void test_assignment_operator_helper(etl::bitset_ext<64>&from, etl::bitset_ext<64>&to)
     {
       to = from;
     }
 
     TEST(test_assignment_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<60> data1(0xFFFFFFFFFFFFFFFULL, buffer1);
-      etl::bitset_ext<60> data2(buffer2);
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      etl::bitset_ext<64> data1(0xFFFFFFFFFFFFFFFULL, buffer1);
+      etl::bitset_ext<64> data2(buffer2);
 
       test_assignment_operator_helper(data1, data2);
 
@@ -1742,15 +1156,14 @@ namespace
     //*************************************************************************
     TEST(test_equality_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64> data1(0x123456781234567ULL, buffer1);
+      etl::bitset_ext<64> data2(0x123456781234567ULL, buffer2);
+      etl::bitset_ext<64> data3(buffer3);
 
-      etl::bitset_ext<60> data1(0x123456781234567ULL, buffer1);
-      etl::bitset_ext<60> data2(0x123456781234567ULL, buffer2);
-      etl::bitset_ext<60> data3(buffer3);
-
-      bool equal     =  (data1 == data2);
+      bool equal = (data1 == data2);
       bool not_equal = !(data1 == data3);
 
       CHECK(equal);
@@ -1760,13 +1173,12 @@ namespace
     //*************************************************************************
     TEST(test_inequality_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-
-      etl::bitset_ext<60> data1(0x123456781234567ULL, buffer1);
-      etl::bitset_ext<60> data2(0x123456781234567ULL, buffer2);
-      etl::bitset_ext<60> data3(buffer3);
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64> data1(0x123456781234567ULL, buffer1);
+      etl::bitset_ext<64> data2(0x123456781234567ULL, buffer2);
+      etl::bitset_ext<64> data3(buffer3);
 
       bool equal = !(data1 != data2);
       bool not_equal = (data1 != data3);
@@ -1776,9 +1188,9 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_shift_left_operator_all_shifts_full_size)
+    TEST(test_shift_left_operator)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
       uint64_t mask = 0xFFFFFFFFFFFFFFFFULL;
 
       etl::bitset_ext<64>::buffer_type buffer1;
@@ -1789,40 +1201,31 @@ namespace
       for (ull shift = 0U; shift < 64U; ++shift)
       {
         etl::bitset_ext<64> data(original, buffer2);
-        CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value<int64_t>());
+        CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value<uint64_t>());
         mask >>= 1;
       }
 
       etl::bitset_ext<64> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value<int64_t>());
+      CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value<uint64_t>());
     }
 
     //*************************************************************************
-    TEST(test_shift_left_operator_all_shifts_partial_size)
+    TEST(test_shift_left_operator_overflow)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
-      uint64_t mask = 0x0FFFFFFFFFFFFFFFULL;
+      etl::bitset_ext<32>::buffer_type buffer1;
+      etl::bitset_ext<32>::buffer_type buffer2;
 
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
+      etl::bitset_ext<32> data(0xFFFFFFFFULL, buffer1);
+      data <<= 1U;
+      etl::bitset_ext<32> shifted(0xFFFFFFFEUL, buffer2);
 
-      etl::bitset_ext<60> original(0x0123456789ABCDEFULL, buffer1);
-
-      for (ull shift = 0U; shift < 64U; ++shift)
-      {        
-        etl::bitset_ext<60> data(original, buffer2);
-        CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value<int64_t>());
-        mask >>= 1;
-      }
-
-      etl::bitset_ext<60> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value<int64_t>());
+      CHECK_EQUAL_HEX(shifted.value<uint32_t>(), data.value<uint32_t>());
     }
 
     //*************************************************************************
-    TEST(test_shift_right_operator_all_shifts_full_size)
+    TEST(test_shift_right_operator)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
 
       etl::bitset_ext<64>::buffer_type buffer1;
       etl::bitset_ext<64>::buffer_type buffer2;
@@ -1832,46 +1235,26 @@ namespace
       for (ull shift = 0U; shift < 64U; ++shift)
       {
         etl::bitset_ext<64> data(original, buffer2);
-        CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value<int64_t>());
+        CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value<uint64_t>());
       }
 
       etl::bitset_ext<64> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value<int64_t>());
-    }
-
-    //*************************************************************************
-    TEST(test_shift_right_operator_all_shifts_partial_size)
-    {
-      int64_t value = 0x0123456789ABCDEFULL;
-
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-
-      etl::bitset_ext<60> original(0x0123456789ABCDEFULL, buffer1);
-
-      for (ull shift = 0U; shift < 64U; ++shift)
-      {
-        etl::bitset_ext<60> data(original, buffer2);
-        CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value<int64_t>());
-      }
-
-      etl::bitset_ext<60> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value<int64_t>());
+      CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value<uint64_t>());
     }
 
     //*************************************************************************
     TEST(test_and_equals_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-      etl::bitset_ext<60>::buffer_type buffer4;
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
 
-      etl::bitset_ext<60> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<60> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<60> data3(0x12345678UL & 0x23456789UL, buffer3);
-      
-      etl::bitset_ext<60> data4(data1, buffer4);
+      etl::bitset_ext<64> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64> data3(0x12345678UL & 0x23456789UL, buffer3);
+
+      etl::bitset_ext<64> data4(data1, buffer4);
       data4 &= data2;
       CHECK(data3 == data4);
     }
@@ -1879,16 +1262,16 @@ namespace
     //*************************************************************************
     TEST(test_or_equals_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-      etl::bitset_ext<60>::buffer_type buffer4;
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
 
-      etl::bitset_ext<60> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<60> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<60> data3(0x12345678UL | 0x23456789UL, buffer3);
+      etl::bitset_ext<64> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64> data3(0x12345678UL | 0x23456789UL, buffer3);
 
-      etl::bitset_ext<60> data4(data1, buffer4);
+      etl::bitset_ext<64> data4(data1, buffer4);
       data4 |= data2;
       CHECK(data3 == data4);
     }
@@ -1896,16 +1279,16 @@ namespace
     //*************************************************************************
     TEST(test_xor_equals_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-      etl::bitset_ext<60>::buffer_type buffer4;
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
 
-      etl::bitset_ext<60> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<60> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<60> data3(0x12345678UL ^ 0x23456789UL, buffer3);
+      etl::bitset_ext<64> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64> data3(0x12345678UL ^ 0x23456789UL, buffer3);
 
-      etl::bitset_ext<60> data4(data1, buffer4);
+      etl::bitset_ext<64> data4(data1, buffer4);
       data4 ^= data2;
       CHECK(data3 == data4);
     }
@@ -1913,66 +1296,57 @@ namespace
     //*************************************************************************
     TEST(test_find_first)
     {
-      etl::bitset_ext<9>::element_type buffer1[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer2[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer3[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer4[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer5[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer6[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer7[etl::bitset_ext<9>::Number_Of_Elements];
+      etl::bitset_ext<8>::buffer_type buffer;
 
-      etl::bitset_ext<9> bs1(ull(0x0000), buffer1);
+      etl::bitset_ext<8> bs1(ull(0x00), buffer);
       size_t bs1fff = bs1.find_first(false);
       size_t bs1fft = bs1.find_first(true);
       CHECK_EQUAL(0U, bs1fff);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fft);
 
-      etl::bitset_ext<9> bs2(ull(0x01FF), buffer2);
+      etl::bitset_ext<8> bs2(ull(0xFF), buffer);
       size_t bs2fff = bs2.find_first(false);
       size_t bs2fft = bs2.find_first(true);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fff);
       CHECK_EQUAL(0U, bs2fft);
 
-      etl::bitset_ext<9> bs3(ull(0x0001), buffer3);
+      etl::bitset_ext<8> bs3(ull(0x01), buffer);
       size_t bs3fff = bs3.find_first(false);
       size_t bs3fft = bs3.find_first(true);
       CHECK_EQUAL(1U, bs3fff);
       CHECK_EQUAL(0U, bs3fft);
 
-      etl::bitset_ext<9> bs4(ull(0x0020), buffer4);
+      etl::bitset_ext<8> bs4(ull(0x20), buffer);
       size_t bs4fff = bs4.find_first(false);
       size_t bs4fft = bs4.find_first(true);
       CHECK_EQUAL(0U, bs4fff);
       CHECK_EQUAL(5U, bs4fft);
 
-      etl::bitset_ext<9> bs5(ull(0x0021), buffer5);
+      etl::bitset_ext<8> bs5(ull(0x21), buffer);
       size_t bs5fff = bs5.find_first(false);
       size_t bs5fft = bs5.find_first(true);
       CHECK_EQUAL(1U, bs5fff);
       CHECK_EQUAL(0U, bs5fft);
 
-      etl::bitset_ext<9> bs6(ull(0x000E), buffer6);
+      etl::bitset_ext<8> bs6(ull(0x0E), buffer);
       size_t bs6fff = bs6.find_first(false);
       size_t bs6fft = bs6.find_first(true);
       CHECK_EQUAL(0U, bs6fff);
       CHECK_EQUAL(1U, bs6fft);
 
-      etl::bitset_ext<9> bs7(ull(0x31), buffer7);
+      etl::bitset_ext<8> bs7(ull(0x31), buffer);
       size_t bs7fff = bs7.find_first(false);
       size_t bs7fft = bs7.find_first(true);
       CHECK_EQUAL(1U, bs7fff);
       CHECK_EQUAL(0U, bs7fft);
     }
-     
+
     //*************************************************************************
     TEST(test_find_next)
     {
-      etl::bitset_ext<9>::element_type buffer1[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer2[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer3[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer4[etl::bitset_ext<9>::Number_Of_Elements];
+      etl::bitset_ext<8>::buffer_type buffer;
 
-      etl::bitset_ext<9> bs1(ull(0x0000), buffer1);
+      etl::bitset_ext<8> bs1(ull(0x00), buffer);
       size_t bs1fnf0 = bs1.find_next(false, 0);
       size_t bs1fnf1 = bs1.find_next(false, 1);
       size_t bs1fnt2 = bs1.find_next(true, 2);
@@ -1980,7 +1354,7 @@ namespace
       CHECK_EQUAL(1U, bs1fnf1);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fnt2);
 
-      etl::bitset_ext<9> bs2(ull(0x1FF), buffer2);
+      etl::bitset_ext<8> bs2(ull(0xFF), buffer);
       size_t bs2fnt0 = bs2.find_next(true, 0);
       size_t bs2fnt1 = bs2.find_next(true, 1);
       size_t bs2fnf2 = bs2.find_next(false, 2);
@@ -1988,7 +1362,7 @@ namespace
       CHECK_EQUAL(1U, bs2fnt1);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fnf2);
 
-      etl::bitset_ext<9> bs3(ull(0x000E), buffer3);
+      etl::bitset_ext<8> bs3(ull(0x0E), buffer);
       size_t bs3fnf0 = bs3.find_next(false, 0);
       size_t bs3fnt1 = bs3.find_next(true, 1);
       size_t bs3fnf2 = bs3.find_next(false, 2);
@@ -1996,7 +1370,7 @@ namespace
       CHECK_EQUAL(1U, bs3fnt1);
       CHECK_EQUAL(4U, bs3fnf2);
 
-      etl::bitset_ext<9> bs4(ull(0x0031), buffer4);
+      etl::bitset_ext<8> bs4(ull(0x31), buffer);
       size_t bs4fnt0 = bs4.find_next(true, 0);
       size_t bs4fnf0 = bs4.find_next(false, 0);
       size_t bs4fnt1 = bs4.find_next(true, 1);
@@ -2005,37 +1379,18 @@ namespace
       CHECK_EQUAL(4U, bs4fnt1);
     }
 
-    //*************************************************************************
-    TEST(test_find_next_github_issue_617)
-    {
-      etl::bitset_ext<64>::element_type buffer1[etl::bitset_ext<64>::Number_Of_Elements];
-      etl::bitset_ext<64>::element_type buffer2[etl::bitset_ext<64>::Number_Of_Elements];
-
-      etl::bitset_ext<64> bs1(ull(0xC000000000000031), buffer1);
-      size_t bs1fnt1 = bs1.find_next(true, 10);
-      size_t bs1fnt2 = bs1.find_next(true, 59);
-      CHECK_EQUAL(62U, bs1fnt1);
-      CHECK_EQUAL(62U, bs1fnt2);
-
-      etl::bitset_ext<64> bs2(ull(0x3FFFFFFFFFFFFFCE), buffer2);
-      size_t bs2fnf1 = bs2.find_next(false, 10);
-      size_t bs2fnf2 = bs2.find_next(false, 59);
-      CHECK_EQUAL(62U, bs2fnf1);
-      CHECK_EQUAL(62U, bs2fnf2);
-    }
-
     //*************************************************************************
     TEST(test_swap)
     {
-      etl::bitset_ext<9>::element_type buffer1[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer2[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer3[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer4[etl::bitset_ext<9>::Number_Of_Elements];
+      etl::bitset_ext<16>::buffer_type buffer1;
+      etl::bitset_ext<16>::buffer_type buffer2;
+      etl::bitset_ext<16>::buffer_type buffer3;
+      etl::bitset_ext<16>::buffer_type buffer4;
 
-      etl::bitset_ext<9> compare1(0x2A, buffer1);
-      etl::bitset_ext<9> compare2(0x15, buffer2);
-      etl::bitset_ext<9> compare1a(0x2A, buffer3);
-      etl::bitset_ext<9> compare2a(0x15, buffer4);
+      etl::bitset_ext<16> compare1(0x2A, buffer1);
+      etl::bitset_ext<16> compare2(0x15, buffer2);
+      etl::bitset_ext<16> compare1a(0x2A, buffer3);
+      etl::bitset_ext<16> compare2a(0x15, buffer4);
 
       swap(compare1a, compare2a);
 
@@ -2046,55 +1401,83 @@ namespace
     //*************************************************************************
     TEST(test_span)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32   = etl::bitset_ext<32>;
+      using span_t = bs32::span_type;
 
-      using span_t = etl::bitset_ext<32>::span_type;
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
 
-      etl::bitset_ext<32> data(0x12345678UL, buffer);
+      span_t s = b.span();
 
-      span_t s = data.span();
-      CHECK_EQUAL(0x78U, s[0]);
-      CHECK_EQUAL(0x56U, s[1]);
-      CHECK_EQUAL(0x34U, s[2]);
-      CHECK_EQUAL(0x12U, s[3]);
+      if (etl::endianness::value() == etl::endian::little)
+      {
+        CHECK_EQUAL(0x78UL, s[0]);
+        CHECK_EQUAL(0x56UL, s[1]);
+        CHECK_EQUAL(0x34UL, s[2]);
+        CHECK_EQUAL(0x12UL, s[3]);
+      }
+      else
+      {
+        CHECK_EQUAL(0x78UL, s[3]);
+        CHECK_EQUAL(0x56UL, s[2]);
+        CHECK_EQUAL(0x34UL, s[1]);
+        CHECK_EQUAL(0x12UL, s[0]);
+      }
+
+      s[2] = 0x9AU;
+      uint32_t value = b.value<uint32_t>();
+      CHECK_EQUAL(0x129A5678UL, value);
     }
 
     //*************************************************************************
     TEST(test_const_span)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32   = etl::bitset_ext<32>;
+      using span_t = etl::bitset<32>::const_span_type;
 
-      using span_t = etl::bitset_ext<32>::const_span_type;
-
-      const etl::bitset_ext<32> b(0x12345678UL, buffer);
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
 
       span_t s = b.span();
-      CHECK_EQUAL(0x78U, s[0]);
-      CHECK_EQUAL(0x56U, s[1]);
-      CHECK_EQUAL(0x34U, s[2]);
-      CHECK_EQUAL(0x12U, s[3]);
+      if (etl::endianness::value() == etl::endian::little)
+      {
+        CHECK_EQUAL(0x78UL, s[0]);
+        CHECK_EQUAL(0x56UL, s[1]);
+        CHECK_EQUAL(0x34UL, s[2]);
+        CHECK_EQUAL(0x12UL, s[3]);
+      }
+      else
+      {
+        CHECK_EQUAL(0x78UL, s[3]);
+        CHECK_EQUAL(0x56UL, s[2]);
+        CHECK_EQUAL(0x34UL, s[1]);
+        CHECK_EQUAL(0x12UL, s[0]);
+      }
     }
 
     //*************************************************************************
     TEST(test_to_string)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32 = etl::bitset_ext<32>;
 
-      etl::bitset_ext<32> b(0x12345678UL, buffer);
+      bs32::buffer_type buffer;
+      bs32 data(0x12345678UL, buffer);
 
-      etl::string<32> text = b.to_string('.', '*');
-      std::string stdtext  = b.to_string<std::string>('.', '*');
+      etl::string<32> text = data.to_string('.', '*');
+      std::string stdtext = data.to_string<std::string>('.', '*');
 
-      CHECK_EQUAL("...*..*...**.*...*.*.**..****...", text.c_str());
-      CHECK_EQUAL("...*..*...**.*...*.*.**..****...", stdtext.c_str());
+      //CHECK_THROW(b.to_string<etl::string<30>>('.', '*'), etl::bitset_ext_overflow);
+      CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(text.c_str()));
+      CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(stdtext.c_str()));
     }
 
     //*************************************************************************
     TEST(test_to_wstring)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32 = etl::bitset_ext<32>;
 
-      etl::bitset_ext<32> b(0x12345678UL, buffer);
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
 
       etl::wstring<32> text = b.to_string<etl::wstring<32>>(L'.', L'*');
       std::wstring stdtext = b.to_string<std::wstring>(L'.', L'*');
@@ -2106,9 +1489,10 @@ namespace
     //*************************************************************************
     TEST(test_to_u16string)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32 = etl::bitset_ext<32>;
 
-      etl::bitset_ext<32> b(0x12345678UL, buffer);
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
 
       etl::u16string<32> text = b.to_string<etl::u16string<32>>(u'.', u'*');
       std::u16string stdtext = b.to_string<std::u16string>(u'.', u'*');
@@ -2120,9 +1504,10 @@ namespace
     //*************************************************************************
     TEST(test_to_u32string)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32 = etl::bitset_ext<32>;
 
-      etl::bitset_ext<32> b(0x12345678UL, buffer);
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
 
       etl::u32string<32> text = b.to_string<etl::u32string<32>>(U'.', U'*');
       std::u32string stdtext = b.to_string<std::u32string>(U'.', U'*');
@@ -2139,16 +1524,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
-      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>(0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>(1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>(2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>(3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>(4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>(5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>(6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>(7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>(8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>(9, 6)));
       CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
       CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
       CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
@@ -2179,16 +1564,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
-      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t, 9, 6>()));
       CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
       CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
       CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
@@ -2220,16 +1605,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
-      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
-      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
       CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
       CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
@@ -2248,8 +1633,8 @@ namespace
       CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
       CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
 
-      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
-      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
     }
 
     //*************************************************************************
@@ -2260,16 +1645,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
-      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
       CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
@@ -2289,8 +1674,8 @@ namespace
       CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
 
       // The lines below should static assert.
-      //int8_t v1 = b.extract<int8_t, 26, 7>();
-      //int8_t v1 = b.extract<int8_t, 27, 6>();
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
     }
 
     //*************************************************************************
@@ -2301,16 +1686,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
-      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
-      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
-      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
-      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>(0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>(1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>(2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>(3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>(4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>(5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>(6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>(7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>(8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>(9, 8));
       CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
       CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
       CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
@@ -2339,16 +1724,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
-      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t, 0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t, 1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t, 2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t, 3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t, 4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t, 5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t, 6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t, 7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t, 8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t, 9, 8>()));
       CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
       CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
       CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
@@ -2378,34 +1763,34 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
-      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
-      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
-      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
-      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
-      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
-      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
-      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
-      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
-      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
-      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
-      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
-      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
-      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
-      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
-      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
-      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
-      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
-      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
-      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
-      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
-      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
-      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
-      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
-      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>(0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>(1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>(2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>(3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>(4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>(5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>(6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>(7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>(8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>(9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
 
-      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
-      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
     }
 
     //*************************************************************************
@@ -2416,35 +1801,35 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
-      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t, 0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t, 1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t, 2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t, 3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t, 4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t, 5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t, 6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t, 7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t, 8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t, 9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
 
       // The lines below should static assert.
-      //int8_t v1 = b.extract<int8_t, 24, 9>();
-      //int8_t v2 = b.extract<int8_t, 25, 8>();
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
     }
 
     //*************************************************************************
@@ -2455,16 +1840,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
-      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>(0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>(1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>(2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>(3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>(4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>(5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>(6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>(7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>(8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>(9, 13));
       CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
       CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
       CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
@@ -2488,16 +1873,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0, 13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1, 13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3, 13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4, 13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5, 13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6, 13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7, 13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8, 13>()));
-      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t, 0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t, 1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t, 2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t, 3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t, 4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t, 5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t, 6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t, 7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t, 8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t, 9, 13>()));
       CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
       CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
       CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
@@ -2522,16 +1907,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
-      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
-      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
-      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>(0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>(1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>(2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>(3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>(4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>(5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>(6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>(7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>(8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>(9, 16));
       CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
       CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
       CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
@@ -2552,16 +1937,16 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
-      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t, 0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t, 1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t, 2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t, 3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t, 4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t, 5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t, 6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t, 7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t, 8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t, 9, 16>()));
       CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
       CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
       CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
@@ -2583,26 +1968,26 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
-      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
-      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
-      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
-      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
-      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
-      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
-      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
-      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
-      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
-      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
-      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
-      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
-      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
-      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
-      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
-      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>(0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>(1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>(2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>(3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>(4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>(5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>(6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>(7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>(8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>(9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
 
-      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
-      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
     }
 
     //*************************************************************************
@@ -2613,27 +1998,27 @@ namespace
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
 
-      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
-      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t, 0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t, 1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t, 2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t, 3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t, 4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t, 5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t, 6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t, 7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t, 8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t, 9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
 
       // The lines below should static assert.
-      //int16_t v1 = b.extract<int16_t, 16, 17>());
-      //int16_t v2 = b.extract<int16_t, 17, 16>());
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>());
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>());
     }
   };
 }
diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp
index cbba1ed4..a26fa6a9 100644
--- a/test/test_bitset_new_ext_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp
@@ -106,15 +106,20 @@ namespace
       etl::bitset_ext<32, uint32_t> data32(buffer32);
       etl::bitset_ext<64, uint64_t> data64(buffer64);
 
+      CHECK_EQUAL(8,  data8.Size);
+      CHECK_EQUAL(16, data16.Size);
+      CHECK_EQUAL(32, data32.Size);
+      CHECK_EQUAL(64, data64.Size);
+
       CHECK_EQUAL(1U, data8.Number_Of_Elements);
       CHECK_EQUAL(1U, data16.Number_Of_Elements);
       CHECK_EQUAL(1U, data32.Number_Of_Elements);
       CHECK_EQUAL(1U, data64.Number_Of_Elements);
 
-      CHECK_EQUAL(etl::bitset_layout::Single, data8.Element_Layout);
-      CHECK_EQUAL(etl::bitset_layout::Single, data16.Element_Layout);
-      CHECK_EQUAL(etl::bitset_layout::Single, data32.Element_Layout);
-      CHECK_EQUAL(etl::bitset_layout::Single, data64.Element_Layout);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data8.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data16.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data32.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data64.Storage_Model);
     }
 
     //*************************************************************************
@@ -1581,6 +1586,9 @@ namespace
 
       span_t s = data.span();
       CHECK_EQUAL(0x12345678UL, s[0]);
+
+      s[0] = 0x87654321UL;
+      CHECK_EQUAL(0x87654321UL, data.value<uint32_t>());
     }
 
     //*************************************************************************
diff --git a/test/vs2022/etl.vcxproj b/test/vs2022/etl.vcxproj
index 473d635c..9bf0209f 100644
--- a/test/vs2022/etl.vcxproj
+++ b/test/vs2022/etl.vcxproj
@@ -7288,6 +7288,7 @@
     <ClCompile Include="..\test_atomic.cpp" />
     <ClCompile Include="..\test_base64.cpp" />
     <ClCompile Include="..\test_bit.cpp" />
+    <ClCompile Include="..\test_bitset_new_comparisons.cpp" />
     <ClCompile Include="..\test_bitset_new_default_element_type.cpp" />
     <ClCompile Include="..\test_bitset_new_explicit_single_element_type.cpp" />
     <ClCompile Include="..\test_bitset_new_ext_default_element_type.cpp" />
diff --git a/test/vs2022/etl.vcxproj.filters b/test/vs2022/etl.vcxproj.filters
index 5c457a21..ba98e37f 100644
--- a/test/vs2022/etl.vcxproj.filters
+++ b/test/vs2022/etl.vcxproj.filters
@@ -3245,9 +3245,6 @@
     <ClCompile Include="..\test_math_functions.cpp">
       <Filter>Tests\Maths</Filter>
     </ClCompile>
-    <ClCompile Include="..\syntax_check\math.h.t.cpp">
-      <Filter>Tests\Maths</Filter>
-    </ClCompile>
     <ClCompile Include="..\test_string_u8.cpp">
       <Filter>Tests\Strings</Filter>
     </ClCompile>
@@ -3284,6 +3281,12 @@
     <ClCompile Include="..\test_crc1.cpp">
       <Filter>Tests\CRC</Filter>
     </ClCompile>
+    <ClCompile Include="..\test_bitset_new_comparisons.cpp">
+      <Filter>Tests\Binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\syntax_check\math.h.t.cpp">
+      <Filter>Tests\Syntax Checks\Source</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\library.properties">

From 9bf8da3d26e7325ef1e0d8c9900fd1c40e6f713b Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Thu, 4 Jan 2024 00:12:36 +0000
Subject: [PATCH 18/26] Updated Arduino library files

---
 arduino/library-arduino.json       | 2 +-
 arduino/library-arduino.properties | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/arduino/library-arduino.json b/arduino/library-arduino.json
index a79a9907..fec95d0c 100644
--- a/arduino/library-arduino.json
+++ b/arduino/library-arduino.json
@@ -1,5 +1,5 @@
 {
-  "name": "Embedded Template Library - Arduino",
+  "name": "Embedded Template Library - ETL",
   "version": "20.38.10",
   "authors": {
     "name": "John Wellbelove",
diff --git a/arduino/library-arduino.properties b/arduino/library-arduino.properties
index 043882bb..c6a8acb8 100644
--- a/arduino/library-arduino.properties
+++ b/arduino/library-arduino.properties
@@ -1,7 +1,7 @@
-name=Embedded Template Library - Arduino
+name=Embedded Template Library - ETL
 version=20.38.10
-author= John Wellbelove <john.wellbelove@etlcpp.com>
-maintainer=John Wellbelove <john.wellbelove@etlcpp.com>
+author= John Wellbelove <arduino@etlcpp.com>
+maintainer=John Wellbelove <arduino@etlcpp.com>
 license=MIT
 sentence=ETL. A C++ template library tailored for embedded systems.
 paragraph=

From ce7ce3bb72ea09c31d92bc66972305cbb76413f8 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Sat, 13 Jan 2024 11:44:40 +0000
Subject: [PATCH 19/26] Make binary functor operator() const

---
 include/etl/binary.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/etl/binary.h b/include/etl/binary.h
index 37e6b00f..903d2bca 100644
--- a/include/etl/binary.h
+++ b/include/etl/binary.h
@@ -2286,7 +2286,7 @@ namespace etl
     //***********************************
     ETL_NODISCARD
     ETL_CONSTEXPR
-    T operator ()(T value) ETL_NOEXCEPT
+    T operator ()(T value) const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
 
@@ -2311,7 +2311,7 @@ namespace etl
     //***********************************
     ETL_NODISCARD
     ETL_CONSTEXPR 
-    T operator ()(T value) ETL_NOEXCEPT
+    T operator ()(T value) const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
 
@@ -2340,7 +2340,7 @@ namespace etl
     //***********************************
     ETL_NODISCARD
     ETL_CONSTEXPR
-    T operator ()(T value) ETL_NOEXCEPT
+    T operator ()(T value) const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
 
@@ -2369,7 +2369,7 @@ namespace etl
     //***********************************
     ETL_NODISCARD
     ETL_CONSTEXPR
-    T operator ()(T value) ETL_NOEXCEPT
+    T operator ()(T value) const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
 

From 8f6055e99bb9d6810807249fe049d4566e0ce668 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Sat, 13 Jan 2024 11:44:59 +0000
Subject: [PATCH 20/26] Removed ETL_STATIC_CONSTANT

---
 include/etl/platform.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/include/etl/platform.h b/include/etl/platform.h
index 294ee7cf..360f9027 100644
--- a/include/etl/platform.h
+++ b/include/etl/platform.h
@@ -249,7 +249,6 @@ SOFTWARE.
   #define ETL_CONSTEXPR                   constexpr
   #define ETL_CONSTEXPR11                 constexpr // Synonym for ETL_CONSTEXPR
   #define ETL_CONSTANT                    constexpr
-  #define ETL_STATIC_CONSTANT             constexpr
   #define ETL_DELETE                      = delete
   #define ETL_EXPLICIT                    explicit
   #define ETL_OVERRIDE                    override
@@ -271,7 +270,6 @@ SOFTWARE.
   #define ETL_CONSTEXPR
   #define ETL_CONSTEXPR11
   #define ETL_CONSTANT                    const
-  #define ETL_STATIC_CONSTANT             static const
   #define ETL_DELETE
   #define ETL_EXPLICIT
   #define ETL_OVERRIDE

From 3ca624efb0bfeb365011ae1372525bec75e635cf Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Sat, 13 Jan 2024 11:45:38 +0000
Subject: [PATCH 21/26] Changed case of template constants

---
 include/etl/bloom_filter.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/etl/bloom_filter.h b/include/etl/bloom_filter.h
index 711a151b..5d35128c 100644
--- a/include/etl/bloom_filter.h
+++ b/include/etl/bloom_filter.h
@@ -62,17 +62,17 @@ namespace etl
   /// An implementation of a bloom filter.
   /// Allows up to three hashes to be defined.
   /// Hashes must support the () operator and define 'argument_type'.
-  ///\tparam DESIRED_WIDTH The desired number of hash results that can be stored. Rounded up to best fit the underlying bitset.
+  ///\tparam Desired_Width The desired number of hash results that can be stored. Rounded up to best fit the underlying bitset.
   ///\tparam THash1        The first hash generator class.
   ///\tparam THash2        The second hash generator class. If omitted, uses the null hash.
   ///\tparam THash3        The third hash generator class.  If omitted, uses the null hash.
   /// The hash classes must define <b>argument_type</b>.
   ///\ingroup bloom_filter
   //***************************************************************************
-  template <size_t DESIRED_WIDTH,
-            typename     THash1,
-            typename     THash2 = private_bloom_filter::null_hash,
-            typename     THash3 = private_bloom_filter::null_hash>
+  template <size_t   Desired_Width,
+            typename THash1,
+            typename THash2 = private_bloom_filter::null_hash,
+            typename THash3 = private_bloom_filter::null_hash>
   class bloom_filter
   {
   private:
@@ -85,7 +85,7 @@ namespace etl
     enum
     {
       // Make the most efficient use of the bitset.
-      WIDTH = etl::bitset<DESIRED_WIDTH>::ALLOCATED_BITS
+      WIDTH = etl::bitset<Desired_Width>::Allocated_Bits
     };
 
     //***************************************************************************

From 3d3dad84991e531488e6782fbe63cd4567bb963a Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Sat, 13 Jan 2024 11:45:57 +0000
Subject: [PATCH 22/26] Work in progress

---
 include/etl/private/bitset_new.h              | 616 ++++++++++++++----
 test/test_bitset_new_default_element_type.cpp | 399 ++++++++++++
 ...itset_new_explicit_single_element_type.cpp | 399 ++++++++++++
 ...st_bitset_new_ext_default_element_type.cpp | 373 +++++++++++
 ...t_new_ext_explicit_single_element_type.cpp | 373 +++++++++++
 5 files changed, 2031 insertions(+), 129 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 1f76a448..8c341eba 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -90,9 +90,18 @@ namespace etl
   //***************************************************************************
   struct bitset_storage_model
   {
-    static ETL_CONSTANT char Undefined = 0;
-    static ETL_CONSTANT char Single    = 1;
-    static ETL_CONSTANT char Multi     = 2;
+    enum enum_type
+    {
+      Undefined = 0,
+      Single    = 1,
+      Multi     = 2
+    };
+
+    ETL_DECLARE_ENUM_TYPE(bitset_storage_model, char)
+    ETL_ENUM_TYPE(Undefined, "Undefined")
+    ETL_ENUM_TYPE(Single,    "Single")
+    ETL_ENUM_TYPE(Multi,     "Multi")
+    ETL_END_ENUM_TYPE
   };
 
   //***************************************************************************
@@ -151,6 +160,37 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  namespace private_bitset
+  {
+    template <typename TElement>
+    class bitset_impl_common
+    {
+    public:
+
+      typedef TElement            element_type;
+      typedef TElement*       pointer;
+      typedef const TElement* const_pointer;
+
+      static ETL_CONSTANT size_t   npos              = etl::integral_limits<size_t>::max;
+      static ETL_CONSTANT size_t   Bits_Per_Element  = etl::integral_limits<TElement>::bits;
+      static ETL_CONSTANT TElement All_Set_Element   = etl::integral_limits<TElement>::max;
+      static ETL_CONSTANT TElement All_Clear_Element = element_type(0);
+    };
+
+    template <typename TElement>
+    ETL_CONSTANT size_t bitset_impl_common<TElement>::npos;
+
+    template <typename TElement>
+    ETL_CONSTANT size_t bitset_impl_common<TElement>::Bits_Per_Element;
+
+    template <typename TElement>
+    ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Set_Element;
+
+    template <typename TElement>
+    ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Clear_Element;
+  }
+
   //*************************************************************************
   /// Bitset implementation declaration.
   ///\ingroup bitset
@@ -163,19 +203,19 @@ namespace etl
   ///\ingroup bitset
   //*************************************************************************
   template <typename TElement>
-  class bitset_impl<TElement, etl::bitset_storage_model::Single>
+  class bitset_impl<TElement, etl::bitset_storage_model::Single> : public etl::private_bitset::bitset_impl_common<TElement>
   {
   public:
 
-    typedef TElement            element_type;
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::element_type;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::pointer;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::const_pointer;
 
-    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
+    using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
 
-    static ETL_CONSTANT size_t       Bits_Per_Element  = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT element_type All_Set_Element   = etl::integral_limits<element_type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
+    using etl::private_bitset::bitset_impl_common<TElement>::npos;
 
     //*************************************************************************
     /// Set all of the bits.
@@ -210,6 +250,47 @@ namespace etl
       }
     }
 
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14
+    static
+    void set_position(pointer pbuffer,
+                      bool    value = true)
+    {
+      const element_type mask = element_type(element_type(1) << Position);
+
+      if (value == true)
+      {
+        *pbuffer |= mask;
+      }
+      else
+      {
+        *pbuffer &= ~mask;
+      }
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position, bool Value>
+    ETL_CONSTEXPR14
+    static
+    void set_position(pointer pbuffer)
+    {
+      const element_type mask = element_type(element_type(1) << Position);
+
+      if (Value == true)
+      {
+        *pbuffer |= mask;
+      }
+      else
+      {
+        *pbuffer &= ~mask;
+      }
+    }
+
     //*************************************************************************
     /// Reset all of the bits.
     //*************************************************************************
@@ -771,19 +852,23 @@ namespace etl
   ///\ingroup bitset
   //*************************************************************************
   template <typename TElement>
-  class bitset_impl<TElement, etl::bitset_storage_model::Multi>
+  class bitset_impl<TElement, etl::bitset_storage_model::Multi> : public etl::private_bitset::bitset_impl_common<TElement>
   {
+  private:
+
+    typedef etl::private_bitset::bitset_impl_common<TElement> common;
+
   public:
 
-    typedef TElement            element_type;
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::element_type;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::pointer;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::const_pointer;
 
-    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
+    using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
 
-    static ETL_CONSTANT size_t       Bits_Per_Element = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits<element_type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
+    using etl::private_bitset::bitset_impl_common<TElement>::npos;
 
     //*************************************************************************
     /// Check to see if the requested extract is contained within one element.
@@ -924,7 +1009,50 @@ namespace etl
       size_t       index = position >> etl::log2<Bits_Per_Element>::value;
       element_type bit   = element_type(1) << (position & (Bits_Per_Element - 1));
 
-      if (value)
+      if (value == true)
+      {
+        pbuffer[index] |= bit;
+      }
+      else
+      {
+        pbuffer[index] &= ~bit;
+      }
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14
+    static
+    void set_position(pointer pbuffer,
+                      bool    value = true)
+    {
+      size_t       index = Position >> etl::log2<Bits_Per_Element>::value;
+      element_type bit   = element_type(1) << (Position & (Bits_Per_Element - 1));
+
+      if (value == true)
+      {
+        pbuffer[index] |= bit;
+      }
+      else
+      {
+        pbuffer[index] &= ~bit;
+      }
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position, bool Value>
+    ETL_CONSTEXPR14
+    static
+    void set_position(pointer pbuffer)
+    {
+      size_t       index = Position >> etl::log2<Bits_Per_Element>::value;
+      element_type bit = element_type(1) << (Position & (Bits_Per_Element - 1));
+
+      if (Value == true)
       {
         pbuffer[index] |= bit;
       }
@@ -1674,6 +1802,55 @@ namespace etl
     }
   };
 
+  namespace private_bitset
+  {
+    //***************************************************************************
+    template <size_t Active_Bits, typename TElement>
+    class bitset_common : public etl::private_bitset::bitset_impl_common<TElement>
+    {
+    public:
+
+      typedef typename etl::private_bitset::bitset_impl_common<TElement>::element_type element_type;
+      
+      using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
+      using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
+      using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
+
+      static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
+      static ETL_CONSTANT size_t Size               = Active_Bits;
+      static ETL_CONSTANT size_t Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
+
+      static ETL_CONSTANT etl::bitset_storage_model Storage_Model = (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
+
+      typedef etl::span<element_type,       Number_Of_Elements> span_type;
+      typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
+
+    private:
+
+      static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - ((Number_Of_Elements * Bits_Per_Element) - Active_Bits)) % Bits_Per_Element);
+
+    public:
+
+      static ETL_CONSTANT TElement Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+    };
+
+
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Number_Of_Elements;
+
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Size;
+
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT etl::bitset_storage_model bitset_common<Active_Bits, TElement>::Storage_Model;
+
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Top_Mask_Shift;
+
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT TElement bitset_common<Active_Bits, TElement>::Top_Mask;  
+  }
+
   //***************************************************************************
   /// Bitset forward declaration
   //***************************************************************************
@@ -1685,61 +1862,46 @@ namespace etl
   /// Specialisation for zero bits.
   //***************************************************************************
   template <>
-  class bitset<0U, unsigned char>
+  class bitset<0U, unsigned char> : public etl::private_bitset::bitset_common<0U, unsigned char>
   {
   public:
 
-    typedef unsigned char element_type;
+    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::element_type    element_type;
+    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::span_type       span_type;
+    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
 
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
-
-    static ETL_CONSTANT size_t       Bits_Per_Element   = 0U;
-    static ETL_CONSTANT size_t       Number_Of_Elements = 0U;
-    static ETL_CONSTANT size_t       Allocated_Bits     = 0U;
-    static ETL_CONSTANT element_type All_Set_Element    = 0U;
-    static ETL_CONSTANT element_type All_Clear_Element  = 0U;
-    static ETL_CONSTANT size_t       Size               = 0U;
-    static ETL_CONSTANT char         Storage_Model      = etl::bitset_storage_model::Undefined;
-
-    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Set_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Size;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Storage_Model;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Top_Mask;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Allocated_Bits;
   };
 
   //*************************************************************************
   /// The bitset top level template.
   //*************************************************************************
   template <size_t Active_Bits, typename TElement>
-  class bitset
+  class bitset : public etl::private_bitset::bitset_common<Active_Bits, TElement>
   {
   public:
 
     ETL_STATIC_ASSERT(etl::is_unsigned<TElement>::value, "The element type must be unsigned");
 
-    typedef TElement            element_type;
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::element_type    element_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::span_type       span_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::const_span_type const_span_type;
 
-    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
-
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
-    static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-    static ETL_CONSTANT size_t       Size               = Active_Bits;
-    static ETL_CONSTANT char         Storage_Model      = (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
-
-  private:
-    
-    static ETL_CONSTANT size_t       Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-    static ETL_CONSTANT element_type Top_Mask       = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
-
-  public:
-
-    static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
-
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Size;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Storage_Model;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Top_Mask;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Allocated_Bits;
 
     //*************************************************************************
     /// The reference type returned.
@@ -1912,7 +2074,8 @@ namespace etl
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(size_t position, bool value = true)
+    ETL_CONSTEXPR14
+    bitset<Active_Bits, TElement>& set(size_t position, bool value = true)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
@@ -1922,11 +2085,27 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const char* text) ETL_NOEXCEPT
+    template <size_t Position>
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(bool value = true)
     {
-      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position>(buffer, value);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position, bool Value>
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set()
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position, Value>(buffer);
 
       return *this;
     }
@@ -1934,7 +2113,10 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const wchar_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
       implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
@@ -1942,9 +2124,12 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const char16_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const wchar_t*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
       implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
@@ -1952,9 +2137,25 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a char16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const char32_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char16_t*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
+    {
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set from a char32 string.
+    //*************************************************************************
+    template <typename TPString>
+    ETL_CONSTEXPR14 
+    typename etl::enable_if<etl::is_same<TPString, const char32_t*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
       implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
@@ -2099,14 +2300,84 @@ namespace etl
       return implementation::test(buffer, position);
     }
  
+    //*************************************************************************
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will not compile.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14 bool test() const
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      return implementation::test(buffer, Position);
+    }
+
     //*************************************************************************
     /// The number of bits in the bitset.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
+    static ETL_CONSTEXPR size_t size() ETL_NOEXCEPT
     {
       return Active_Bits;
     }
 
+    //*************************************************************************
+    /// The number of storage elements in the bitset.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t number_of_elements() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements;
+    }
+
+    //*************************************************************************
+    /// The value of a set element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type all_set_element() ETL_NOEXCEPT
+    {
+      return All_Set_Element;
+    }
+
+    //*************************************************************************
+    /// The value of a clear element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type all_clear_element() ETL_NOEXCEPT
+    {
+      return All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// The number of bits in an element.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t bits_per_element() ETL_NOEXCEPT
+    {
+      return Bits_Per_Element;
+    }
+
+    //*************************************************************************
+    /// The mask for the msb element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type top_mask() ETL_NOEXCEPT
+    {
+      return Top_Mask;
+    }
+
+    //*************************************************************************
+    /// The total number of bits of storage, including unused.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t allocated_bits() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements * Bits_Per_Element;
+    }
+
+    //*************************************************************************
+    /// The storage model for the bitset.
+    /// etl::bitset_storage_model::Single
+    /// etl::bitset_storage_model::Multi
+    //*************************************************************************
+    static ETL_CONSTEXPR etl::bitset_storage_model storage_model() ETL_NOEXCEPT
+    {
+      return Storage_Model;
+    }
+
     //*************************************************************************
     /// Count the number of bits set.
     //*************************************************************************
@@ -2507,62 +2778,48 @@ namespace etl
   /// Specialisation for zero bits.
   //***************************************************************************
   template <>
-  class bitset_ext<0U, unsigned char>
+  class bitset_ext<0U, unsigned char> : public etl::private_bitset::bitset_common<0U, unsigned char>
   {
   public:
 
-    typedef unsigned char element_type;
+    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::element_type    element_type;
+    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::span_type       span_type;
+    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
 
-    typedef element_type* pointer;
-    typedef const element_type* const_pointer;
-
-    static ETL_CONSTANT size_t       Bits_Per_Element   = 0U;
-    static ETL_CONSTANT size_t       Number_Of_Elements = 0U;
-    static ETL_CONSTANT size_t       Allocated_Bits     = 0U;
-    static ETL_CONSTANT element_type All_Set_Element    = 0U;
-    static ETL_CONSTANT element_type All_Clear_Element  = 0U;
-    static ETL_CONSTANT size_t       Size               = 0U;
-    static ETL_CONSTANT char         Storage_Model      = etl::bitset_storage_model::Undefined;
-
-    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Set_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Size;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Storage_Model;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Top_Mask;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Allocated_Bits;
   };
 
   //*************************************************************************
-  /// The specialisation that uses an array of the default element type.
+  /// A bitset that uses externally declared storage.
   //*************************************************************************
   template <size_t Active_Bits, typename TElement>
-  class bitset_ext
+  class bitset_ext : public etl::private_bitset::bitset_common<Active_Bits, TElement>
   {
   public:
 
     ETL_STATIC_ASSERT(etl::is_unsigned<TElement>::value, "The element type must be unsigned");
 
-    typedef TElement            element_type;
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::element_type    element_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::span_type       span_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::const_span_type const_span_type;
+    
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Size;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Storage_Model;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Top_Mask;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Allocated_Bits;
 
-    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
-
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
-    static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-    static ETL_CONSTANT size_t       Size               = Active_Bits;
-    static ETL_CONSTANT char         Storage_Model      = (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
-
-  private:
-
-    static ETL_CONSTANT size_t       Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-    static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
-
-  public:
-
-    static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
-
-    typedef etl::array<TElement, Number_Of_Elements>          buffer_type;
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
+    typedef etl::array<TElement, Number_Of_Elements> buffer_type;
 
     //*************************************************************************
     /// The reference type returned.
@@ -2811,21 +3068,38 @@ namespace etl
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(size_t position, bool value = true)
+    ETL_CONSTEXPR14
+      bitset_ext<Active_Bits, TElement>& set(size_t position, bool value = true)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
+
       implementation::set_position(pbuffer, position, value);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char* text) ETL_NOEXCEPT
+    template <size_t Position>
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(bool value = true)
     {
-      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position>(pbuffer, value);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position, bool Value>
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set()
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position, Value>(pbuffer);
 
       return *this;
     }
@@ -2833,7 +3107,10 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const wchar_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
       implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
@@ -2841,9 +3118,12 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char16_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const wchar_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
       implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
@@ -2851,9 +3131,25 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a char16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char32_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char16_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
+    {
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set from a char32 string.
+    //*************************************************************************
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char32_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
       implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
@@ -2997,14 +3293,84 @@ namespace etl
       return implementation::test(pbuffer, position);
     }
 
+    //*************************************************************************
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will not compile.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14 bool test() const
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      return implementation::test(pbuffer, Position);
+    }
+
     //*************************************************************************
     /// The number of bits in the bitset.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
+    static ETL_CONSTEXPR size_t size() ETL_NOEXCEPT
     {
       return Active_Bits;
     }
 
+    //*************************************************************************
+    /// The number of storage elements in the bitset.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t number_of_elements() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements;
+    }
+
+    //*************************************************************************
+    /// The value of a set element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type all_set_element() ETL_NOEXCEPT
+    {
+      return All_Set_Element;
+    }
+
+    //*************************************************************************
+    /// The value of a clear element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type all_clear_element() ETL_NOEXCEPT
+    {
+      return All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// The mask for the msb element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type top_mask() ETL_NOEXCEPT
+    {
+      return Top_Mask;
+    }
+
+    //*************************************************************************
+    /// The number of bits in an element.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t bits_per_element() ETL_NOEXCEPT
+    {
+      return Bits_Per_Element;
+    }
+
+    //*************************************************************************
+    /// The total number of bits of storage, including unused.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t allocated_bits() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements * Bits_Per_Element;
+    }
+
+    //*************************************************************************
+    /// The storage model for the bitset.
+    /// etl::bitset_storage_model::Single
+    /// etl::bitset_storage_model::Multi
+    //*************************************************************************
+    static ETL_CONSTEXPR etl::bitset_storage_model storage_model() ETL_NOEXCEPT
+    {
+      return Storage_Model;
+    }
+
     //*************************************************************************
     /// Count the number of bits set.
     //*************************************************************************
@@ -3234,14 +3600,6 @@ namespace etl
 
   private:
 
-    ////*************************************************************************
-    ///// Correct the unused top bits after bit manipulation.
-    ////*************************************************************************
-    //ETL_CONSTEXPR14 static void clear_unused_bits_in_msb() ETL_NOEXCEPT
-    //{
-    //  pbuffer[Number_Of_Elements - 1U] &= Top_Mask;
-    //}
-
     // The implementation of the bitset functionality.
     typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi> implementation;
 
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index 1a38ef2b..4ca19920 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -120,6 +120,77 @@ namespace
 
   SUITE(test_bitset_new_default_element_type)
   {
+    //*************************************************************************
+    TEST(test_constants)
+    {
+      using bitset_type  = etl::bitset<60>;
+      using element_type = bitset_type::element_type;
+
+      constexpr size_t       Size               = 60;
+      constexpr size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
+      constexpr size_t       Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
+      constexpr element_type All_Set_Element    = etl::integral_limits<element_type>::max;
+      constexpr element_type All_Clear_Element  = etl::integral_limits<element_type>::min;
+
+      //*******************************
+      constexpr size_t Size1 = bitset_type::Size;
+      constexpr size_t Size2 = bitset_type::size();
+
+      CHECK_EQUAL(Size, Size1);
+      CHECK_EQUAL(Size, Size2);
+
+      //*******************************
+      constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
+      constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
+
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
+
+      //*******************************
+      constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
+      constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
+      
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
+
+      //*******************************
+      constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
+      constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
+
+      CHECK_EQUAL(All_Set_Element, All_Set_Element1);
+      CHECK_EQUAL(All_Set_Element, All_Set_Element2);
+
+      //*******************************
+      constexpr size_t All_Clear_Element1 = bitset_type::All_Clear_Element;
+      constexpr size_t All_Clear_Element2 = bitset_type::all_clear_element();
+
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
+
+      //*******************************
+      constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
+
+      CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
+
+      //*******************************
+      constexpr char Storage_Model1 = bitset_type::Storage_Model;
+      constexpr char Storage_Model2 = bitset_type::storage_model();
+
+      CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model1);
+      CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model2);
+
+      etl::bitset_storage_model bsm;
+      
+      bsm = etl::bitset_storage_model::Undefined;
+      CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Single;
+      CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Multi;
+      CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
+    }
+
     //*************************************************************************
     TEST(test_default_constructor)
     {
@@ -394,6 +465,281 @@ namespace
       }
     }
 
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_run_time_position_default_value_helper()
+    {
+      etl::bitset<64> data;
+
+      data.set(2);
+      data.set(3);
+      data.set(5);
+      data.set(7);
+      data.set(11);
+      data.set(13);
+      data.set(17);
+      data.set(19);
+      data.set(23);
+      data.set(29);
+      data.set(31);
+
+      return data;
+    }
+
+    TEST(test_set_run_time_position_default_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_run_time_position_default_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_run_time_position_value_helper()
+    {
+      etl::bitset<64> data;
+
+      data.set(2, true);
+      data.set(3, true);
+      data.set(5, true);
+      data.set(7, true);
+      data.set(11, true);
+      data.set(13, true);
+      data.set(17, true);
+      data.set(19, true);
+      data.set(23, true);
+      data.set(29, true);
+      data.set(31, true);
+
+      return data;
+    }
+
+    TEST(test_set_run_time_position_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_run_time_position_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_compile_time_position_run_time_default_value_helper()
+    {
+      etl::bitset<64> data;
+
+      data.set<2>();
+      data.set<3>();
+      data.set<5>();
+      data.set<7>();
+      data.set<11>();
+      data.set<13>();
+      data.set<17>();
+      data.set<19>();
+      data.set<23>();
+      data.set<29>();
+      data.set<31>();
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_run_time_default_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_compile_time_position_run_time_default_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_compile_time_position_run_time_value_helper()
+    {
+      etl::bitset<64> data;
+
+      data.set<2>(true);
+      data.set<3>(true);
+      data.set<5>(true);
+      data.set<7>(true);
+      data.set<11>(true);
+      data.set<13>(true);
+      data.set<17>(true);
+      data.set<19>(true);
+      data.set<23>(true);
+      data.set<29>(true);
+      data.set<31>(true);
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_run_time_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_compile_time_position_run_time_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_compile_time_position_value_helper()
+    {
+      etl::bitset<64> data;
+
+      data.set<2, true>();
+      data.set<3, true>();
+      data.set<5, true>();
+      data.set<7, true>();
+      data.set<11, true>();
+      data.set<13, true>();
+      data.set<17, true>();
+      data.set<19, true>();
+      data.set<23, true>();
+      data.set<29, true>();
+      data.set<31, true>();
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_compile_time_position_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
     //*************************************************************************
     TEST(test_set_with_char_string)
     {
@@ -2255,5 +2601,58 @@ namespace
       //int16_t v1 = b.extract<int16_t, 16, 17>());
       //int16_t v2 = b.extract<int16_t, 17, 16>());
     }
+
+    //*************************************************************************
+    bool test_bit(int i)
+    {
+      return (0x1234 & (1 << i)) != 0;
+    }
+
+    TEST(test_test_run_time)
+    {
+      ETL_CONSTEXPR14 etl::bitset<16> b(0x1234);
+
+      ETL_CONSTEXPR14 bool t0 = b.test(0);
+      ETL_CONSTEXPR14 bool t1 = b.test(1);
+      ETL_CONSTEXPR14 bool t2 = b.test(2);
+      ETL_CONSTEXPR14 bool t3 = b.test(3);
+      ETL_CONSTEXPR14 bool t4 = b.test(4);
+      ETL_CONSTEXPR14 bool t5 = b.test(5);
+      ETL_CONSTEXPR14 bool t6 = b.test(6);
+      ETL_CONSTEXPR14 bool t7 = b.test(7);
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
+
+    //*************************************************************************
+    TEST(test_test_compile_time)
+    {
+      ETL_CONSTEXPR14 etl::bitset<16> b(0x1234);
+
+      ETL_CONSTEXPR14 bool t0 = b.test<0>();
+      ETL_CONSTEXPR14 bool t1 = b.test<1>();
+      ETL_CONSTEXPR14 bool t2 = b.test<2>();
+      ETL_CONSTEXPR14 bool t3 = b.test<3>();
+      ETL_CONSTEXPR14 bool t4 = b.test<4>();
+      ETL_CONSTEXPR14 bool t5 = b.test<5>();
+      ETL_CONSTEXPR14 bool t6 = b.test<6>();
+      ETL_CONSTEXPR14 bool t7 = b.test<7>();
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
   };
 }
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index 0ce70049..91411477 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -119,6 +119,77 @@ namespace
 
   SUITE(test_bitset_new_explicit_element_type)
   {
+    //*************************************************************************
+    TEST(test_constants)
+    {
+      using bitset_type  = etl::bitset<60, uint64_t>;
+      using element_type = bitset_type::element_type;
+
+      constexpr size_t       Size               = 60;
+      constexpr size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
+      constexpr size_t       Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
+      constexpr element_type All_Set_Element    = etl::integral_limits<element_type>::max;
+      constexpr element_type All_Clear_Element  = etl::integral_limits<element_type>::min;
+
+      //*******************************
+      constexpr size_t Size1 = bitset_type::Size;
+      constexpr size_t Size2 = bitset_type::size();
+
+      CHECK_EQUAL(Size, Size1);
+      CHECK_EQUAL(Size, Size2);
+
+      //*******************************
+      constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
+      constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
+
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
+
+      //*******************************
+      constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
+      constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
+
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
+
+      //*******************************
+      constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
+      constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
+
+      CHECK_EQUAL(All_Set_Element, All_Set_Element1);
+      CHECK_EQUAL(All_Set_Element, All_Set_Element2);
+
+      //*******************************
+      constexpr element_type All_Clear_Element1 = bitset_type::All_Clear_Element;
+      constexpr element_type All_Clear_Element2 = bitset_type::all_clear_element();
+
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
+
+      //*******************************
+      constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
+
+      CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
+
+      //*******************************
+      constexpr char Storage_Model1 = bitset_type::Storage_Model;
+      constexpr char Storage_Model2 = bitset_type::storage_model();
+
+      CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model1);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model2);
+
+      etl::bitset_storage_model bsm;
+
+      bsm = etl::bitset_storage_model::Undefined;
+      CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Single;
+      CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Multi;
+      CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
+    }
+
     //*************************************************************************
     TEST(test_default_constructor)
     {
@@ -390,6 +461,281 @@ namespace
       }
     }
 
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_run_time_position_default_value_helper()
+    {
+      etl::bitset<64, uint64_t> data;
+
+      data.set(2);
+      data.set(3);
+      data.set(5);
+      data.set(7);
+      data.set(11);
+      data.set(13);
+      data.set(17);
+      data.set(19);
+      data.set(23);
+      data.set(29);
+      data.set(31);
+
+      return data;
+    }
+
+    TEST(test_set_run_time_position_default_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_run_time_position_default_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_run_time_position_value_helper()
+    {
+      etl::bitset<64, uint64_t> data;
+
+      data.set(2, true);
+      data.set(3, true);
+      data.set(5, true);
+      data.set(7, true);
+      data.set(11, true);
+      data.set(13, true);
+      data.set(17, true);
+      data.set(19, true);
+      data.set(23, true);
+      data.set(29, true);
+      data.set(31, true);
+
+      return data;
+    }
+
+    TEST(test_set_run_time_position_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_run_time_position_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_compile_time_position_run_time_default_value_helper()
+    {
+      etl::bitset<64, uint64_t> data;
+
+      data.set<2>();
+      data.set<3>();
+      data.set<5>();
+      data.set<7>();
+      data.set<11>();
+      data.set<13>();
+      data.set<17>();
+      data.set<19>();
+      data.set<23>();
+      data.set<29>();
+      data.set<31>();
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_run_time_default_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_compile_time_position_run_time_default_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_compile_time_position_run_time_value_helper()
+    {
+      etl::bitset<64, uint64_t> data;
+
+      data.set<2>(true);
+      data.set<3>(true);
+      data.set<5>(true);
+      data.set<7>(true);
+      data.set<11>(true);
+      data.set<13>(true);
+      data.set<17>(true);
+      data.set<19>(true);
+      data.set<23>(true);
+      data.set<29>(true);
+      data.set<31>(true);
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_run_time_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_compile_time_position_run_time_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_compile_time_position_value_helper()
+    {
+      etl::bitset<64, uint64_t> data;
+
+      data.set<2, true>();
+      data.set<3, true>();
+      data.set<5, true>();
+      data.set<7, true>();
+      data.set<11, true>();
+      data.set<13, true>();
+      data.set<17, true>();
+      data.set<19, true>();
+      data.set<23, true>();
+      data.set<29, true>();
+      data.set<31, true>();
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_compile_time_position_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
     //*************************************************************************
     TEST(test_set_with_char_string)
     {
@@ -2348,5 +2694,58 @@ namespace
       //int16_t v1 = b.extract<int16_t, 16, 17>());
       //int16_t v2 = b.extract<int16_t, 17, 16>());
     }
+
+    //*************************************************************************
+    bool test_bit(int i)
+    {
+      return (0x1234 & (1 << i)) != 0;
+    }
+
+    TEST(test_test_run_time)
+    {
+      ETL_CONSTEXPR14 etl::bitset<16, uint16_t> b(0x1234);
+
+      ETL_CONSTEXPR14 bool t0 = b.test(0);
+      ETL_CONSTEXPR14 bool t1 = b.test(1);
+      ETL_CONSTEXPR14 bool t2 = b.test(2);
+      ETL_CONSTEXPR14 bool t3 = b.test(3);
+      ETL_CONSTEXPR14 bool t4 = b.test(4);
+      ETL_CONSTEXPR14 bool t5 = b.test(5);
+      ETL_CONSTEXPR14 bool t6 = b.test(6);
+      ETL_CONSTEXPR14 bool t7 = b.test(7);
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
+
+    //*************************************************************************
+    TEST(test_test_compile_time)
+    {
+      ETL_CONSTEXPR14 etl::bitset<16, uint16_t> b(0x1234);
+
+      ETL_CONSTEXPR14 bool t0 = b.test<0>();
+      ETL_CONSTEXPR14 bool t1 = b.test<1>();
+      ETL_CONSTEXPR14 bool t2 = b.test<2>();
+      ETL_CONSTEXPR14 bool t3 = b.test<3>();
+      ETL_CONSTEXPR14 bool t4 = b.test<4>();
+      ETL_CONSTEXPR14 bool t5 = b.test<5>();
+      ETL_CONSTEXPR14 bool t6 = b.test<6>();
+      ETL_CONSTEXPR14 bool t7 = b.test<7>();
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
   };
 }
diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp
index d62d5c42..6945376d 100644
--- a/test/test_bitset_new_ext_default_element_type.cpp
+++ b/test/test_bitset_new_ext_default_element_type.cpp
@@ -45,6 +45,77 @@ namespace
 
   SUITE(test_bitset_new_ext_default_element_type)
   {
+    //*************************************************************************
+    TEST(test_constants)
+    {
+      using bitset_type  = etl::bitset_ext<60>;
+      using element_type = bitset_type::element_type;
+
+      constexpr size_t       Size               = 60;
+      constexpr size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
+      constexpr size_t       Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
+      constexpr element_type All_Set_Element    = etl::integral_limits<element_type>::max;
+      constexpr element_type All_Clear_Element  = etl::integral_limits<element_type>::min;
+
+      //*******************************
+      constexpr size_t Size1 = bitset_type::Size;
+      constexpr size_t Size2 = bitset_type::size();
+
+      CHECK_EQUAL(Size, Size1);
+      CHECK_EQUAL(Size, Size2);
+
+      //*******************************
+      constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
+      constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
+
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
+
+      //*******************************
+      constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
+      constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
+
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
+
+      //*******************************
+      constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
+      constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
+
+      CHECK_EQUAL(All_Set_Element, All_Set_Element1);
+      CHECK_EQUAL(All_Set_Element, All_Set_Element2);
+
+      //*******************************
+      constexpr element_type All_Clear_Element1 = bitset_type::All_Clear_Element;
+      constexpr element_type All_Clear_Element2 = bitset_type::all_clear_element();
+
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
+
+      //*******************************
+      constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
+
+      CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
+
+      //*******************************
+      constexpr char Storage_Model1 = bitset_type::Storage_Model;
+      constexpr char Storage_Model2 = bitset_type::storage_model();
+
+      CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model1);
+      CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model2);
+
+      etl::bitset_storage_model bsm;
+
+      bsm = etl::bitset_storage_model::Undefined;
+      CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Single;
+      CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Multi;
+      CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
+    }
+
     //*************************************************************************
     TEST(test_construct_from_nullptr_buffer)
     {
@@ -334,6 +405,251 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_set_run_time_position_default_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set(2);
+      data.set(3);
+      data.set(5);
+      data.set(7);
+      data.set(11);
+      data.set(13);
+      data.set(17);
+      data.set(19);
+      data.set(23);
+      data.set(29);
+      data.set(31);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_run_time_position_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set(2, true);
+      data.set(3, true);
+      data.set(5, true);
+      data.set(7, true);
+      data.set(11, true);
+      data.set(13, true);
+      data.set(17, true);
+      data.set(19, true);
+      data.set(23, true);
+      data.set(29, true);
+      data.set(31, true);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_run_time_default_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2>();
+      data.set<3>();
+      data.set<5>();
+      data.set<7>();
+      data.set<11>();
+      data.set<13>();
+      data.set<17>();
+      data.set<19>();
+      data.set<23>();
+      data.set<29>();
+      data.set<31>();
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_run_time_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2>(true);
+      data.set<3>(true);
+      data.set<5>(true);
+      data.set<7>(true);
+      data.set<11>(true);
+      data.set<13>(true);
+      data.set<17>(true);
+      data.set<19>(true);
+      data.set<23>(true);
+      data.set<29>(true);
+      data.set<31>(true);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2, true>();
+      data.set<3, true>();
+      data.set<5, true>();
+      data.set<7, true>();
+      data.set<11, true>();
+      data.set<13, true>();
+      data.set<17, true>();
+      data.set<19, true>();
+      data.set<23, true>();
+      data.set<29, true>();
+      data.set<31, true>();
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
     //*************************************************************************
     TEST(test_set_with_char_string)
     {
@@ -2020,5 +2336,62 @@ namespace
       //uint16_t v1 = b.extract<uint16_t, 16, 17>());
       //uint16_t v2 = b.extract<uint16_t, 17, 16>());
     }
+
+    //*************************************************************************
+    bool test_bit(int i)
+    {
+      return (0x1234 & (1 << i)) != 0;
+    }
+
+    TEST(test_test_run_time)
+    {
+      etl::bitset_ext<16>::buffer_type buffer;
+
+      etl::bitset_ext<16> b(0x1234, buffer);
+
+      bool t0 = b.test(0);
+      bool t1 = b.test(1);
+      bool t2 = b.test(2);
+      bool t3 = b.test(3);
+      bool t4 = b.test(4);
+      bool t5 = b.test(5);
+      bool t6 = b.test(6);
+      bool t7 = b.test(7);
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
+
+    //*************************************************************************
+    TEST(test_test_compile_time)
+    {
+      etl::bitset_ext<16>::buffer_type buffer;
+
+      etl::bitset_ext<16> b(0x1234, buffer);
+
+      bool t0 = b.test<0>();
+      bool t1 = b.test<1>();
+      bool t2 = b.test<2>();
+      bool t3 = b.test<3>();
+      bool t4 = b.test<4>();
+      bool t5 = b.test<5>();
+      bool t6 = b.test<6>();
+      bool t7 = b.test<7>();
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
   };
 }
diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp
index a26fa6a9..d98c779d 100644
--- a/test/test_bitset_new_ext_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp
@@ -44,6 +44,77 @@ namespace
 
   SUITE(test_bitset_new_ext_explicit_element_type)
   {
+    //*************************************************************************
+    TEST(test_constants)
+    {
+      using bitset_type  = etl::bitset_ext<60, uint64_t>;
+      using element_type = bitset_type::element_type;
+
+      constexpr size_t       Size               = 60;
+      constexpr size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
+      constexpr size_t       Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
+      constexpr element_type All_Set_Element    = etl::integral_limits<element_type>::max;
+      constexpr element_type All_Clear_Element  = etl::integral_limits<element_type>::min;
+
+      //*******************************
+      constexpr size_t Size1 = bitset_type::Size;
+      constexpr size_t Size2 = bitset_type::size();
+
+      CHECK_EQUAL(Size, Size1);
+      CHECK_EQUAL(Size, Size2);
+
+      //*******************************
+      constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
+      constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
+
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
+
+      //*******************************
+      constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
+      constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
+
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
+
+      //*******************************
+      constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
+      constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
+
+      CHECK_EQUAL(All_Set_Element, All_Set_Element1);
+      CHECK_EQUAL(All_Set_Element, All_Set_Element2);
+
+      //*******************************
+      constexpr size_t All_Clear_Element1 = bitset_type::All_Clear_Element;
+      constexpr size_t All_Clear_Element2 = bitset_type::all_clear_element();
+
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
+
+      //*******************************
+      constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
+
+      CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
+
+      //*******************************
+      constexpr char Storage_Model1 = bitset_type::Storage_Model;
+      constexpr char Storage_Model2 = bitset_type::storage_model();
+
+      CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model1);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model2);
+
+      etl::bitset_storage_model bsm;
+
+      bsm = etl::bitset_storage_model::Undefined;
+      CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Single;
+      CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Multi;
+      CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
+    }
+
     //*************************************************************************
     TEST(test_construct_from_nullptr_buffer)
     {
@@ -362,6 +433,251 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_set_run_time_position_default_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set(2);
+      data.set(3);
+      data.set(5);
+      data.set(7);
+      data.set(11);
+      data.set(13);
+      data.set(17);
+      data.set(19);
+      data.set(23);
+      data.set(29);
+      data.set(31);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_run_time_position_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set(2, true);
+      data.set(3, true);
+      data.set(5, true);
+      data.set(7, true);
+      data.set(11, true);
+      data.set(13, true);
+      data.set(17, true);
+      data.set(19, true);
+      data.set(23, true);
+      data.set(29, true);
+      data.set(31, true);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_run_time_default_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2>();
+      data.set<3>();
+      data.set<5>();
+      data.set<7>();
+      data.set<11>();
+      data.set<13>();
+      data.set<17>();
+      data.set<19>();
+      data.set<23>();
+      data.set<29>();
+      data.set<31>();
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_run_time_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2>(true);
+      data.set<3>(true);
+      data.set<5>(true);
+      data.set<7>(true);
+      data.set<11>(true);
+      data.set<13>(true);
+      data.set<17>(true);
+      data.set<19>(true);
+      data.set<23>(true);
+      data.set<29>(true);
+      data.set<31>(true);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2, true>();
+      data.set<3, true>();
+      data.set<5, true>();
+      data.set<7, true>();
+      data.set<11, true>();
+      data.set<13, true>();
+      data.set<17, true>();
+      data.set<19, true>();
+      data.set<23, true>();
+      data.set<29, true>();
+      data.set<31, true>();
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
     //*************************************************************************
     TEST(test_set_with_char_string)
     {
@@ -2168,5 +2484,62 @@ namespace
       //uint16_t v1 = b.extract<uint16_t, 16, 17>());
       //uint16_t v2 = b.extract<uint16_t, 17, 16>());
     }
+
+    //*************************************************************************
+    bool test_bit(int i)
+    {
+      return (0x1234 & (1 << i)) != 0;
+    }
+
+    TEST(test_test_run_time)
+    {
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+
+      etl::bitset_ext<16, uint16_t> b(0x1234, buffer);
+
+      bool t0 = b.test(0);
+      bool t1 = b.test(1);
+      bool t2 = b.test(2);
+      bool t3 = b.test(3);
+      bool t4 = b.test(4);
+      bool t5 = b.test(5);
+      bool t6 = b.test(6);
+      bool t7 = b.test(7);
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
+
+    //*************************************************************************
+    TEST(test_test_compile_time)
+    {
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+
+      etl::bitset_ext<16, uint16_t> b(0x1234, buffer);
+
+      bool t0 = b.test<0>();
+      bool t1 = b.test<1>();
+      bool t2 = b.test<2>();
+      bool t3 = b.test<3>();
+      bool t4 = b.test<4>();
+      bool t5 = b.test<5>();
+      bool t6 = b.test<6>();
+      bool t7 = b.test<7>();
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
   };
 }

From 47d3d67a147404f268fd32e5c6cb5829d30aab31 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Thu, 18 Jan 2024 09:54:07 +0000
Subject: [PATCH 23/26] Modified definition of bitset::Storage_Type for
 compatibility with C++03

---
 include/etl/private/bitset_new.h | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 8c341eba..6c6d2443 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -1820,7 +1820,11 @@ namespace etl
       static ETL_CONSTANT size_t Size               = Active_Bits;
       static ETL_CONSTANT size_t Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
 
-      static ETL_CONSTANT etl::bitset_storage_model Storage_Model = (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
+#if ETL_USING_CPP11
+      static ETL_CONSTANT etl::bitset_storage_model Storage_Model = (bitset_common<Active_Bits, TElement>::Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
+#else
+      static ETL_CONSTANT etl::bitset_storage_model Storage_Model;
+#endif
 
       typedef etl::span<element_type,       Number_Of_Elements> span_type;
       typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
@@ -1841,8 +1845,13 @@ namespace etl
     template <size_t Active_Bits, typename TElement>
     ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Size;
 
+#if ETL_USING_CPP11
     template <size_t Active_Bits, typename TElement>
     ETL_CONSTANT etl::bitset_storage_model bitset_common<Active_Bits, TElement>::Storage_Model;
+#else
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT etl::bitset_storage_model bitset_common<Active_Bits, TElement>::Storage_Model = (bitset_common<Active_Bits, TElement>::Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
+#endif
 
     template <size_t Active_Bits, typename TElement>
     ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Top_Mask_Shift;

From 1825c545705c7af03dd91a5b8303191fcecfe8cf Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Sat, 20 Jan 2024 09:44:51 +0000
Subject: [PATCH 24/26] Minor C++ standards compatibility tweaks

---
 include/etl/private/bitset_new.h | 44 ++++++++++++++++++++------------
 1 file changed, 28 insertions(+), 16 deletions(-)

diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 6c6d2443..6d653298 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -459,7 +459,7 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value from an arbitrary position and length.
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
@@ -484,9 +484,13 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value from an arbitrary position and length.
     //*************************************************************************
+#if ETL_USING_CPP11
     template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+#else
+		template <typename T, size_t Position, size_t Length>
+#endif
     ETL_CONSTEXPR14
       static
       T extract(const_pointer pbuffer)
@@ -1309,7 +1313,7 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value from an arbitrary position and length.
     /// Run time position and length.
     //*************************************************************************
     template <typename T>
@@ -1387,7 +1391,7 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value from an arbitrary position and length.
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
@@ -1409,7 +1413,7 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value from an arbitrary position and length.
     //*************************************************************************
     template <typename T, size_t Position, size_t Length>
     ETL_CONSTEXPR14
@@ -1875,9 +1879,9 @@ namespace etl
   {
   public:
 
-    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::element_type    element_type;
-    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::span_type       span_type;
-    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::element_type    element_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::span_type       span_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
 
     using etl::private_bitset::bitset_common<0U, unsigned char>::Bits_Per_Element;
     using etl::private_bitset::bitset_common<0U, unsigned char>::All_Set_Element;
@@ -2226,7 +2230,7 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value from an arbitrary position and length.
     /// Run time position and length.
     //*************************************************************************
     template <typename T>
@@ -2242,10 +2246,14 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value from an arbitrary position and length.
     /// Compile time position and length.
     //*************************************************************************
-    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+#if ETL_USING_CPP11    
+		template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+#else
+	  template <typename T, size_t Position, size_t Length>
+#endif
     ETL_CONSTEXPR14
     T extract() const
     {
@@ -2791,9 +2799,9 @@ namespace etl
   {
   public:
 
-    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::element_type    element_type;
-    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::span_type       span_type;
-    typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::element_type    element_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::span_type       span_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
 
     using etl::private_bitset::bitset_common<0U, unsigned char>::Bits_Per_Element;
     using etl::private_bitset::bitset_common<0U, unsigned char>::All_Set_Element;
@@ -3219,7 +3227,7 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value from an arbitrary position and length.
     /// Run time position and length.
     //*************************************************************************
     template <typename T>
@@ -3235,10 +3243,14 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Extract an integral value from an arbitary position and length.
+    /// Extract an integral value from an arbitrary position and length.
     /// Compile time position and length.
     //*************************************************************************
+#if ETL_USING_CPP11
     template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+#else
+    template <typename T, size_t Position, size_t Length>
+#endif
     ETL_CONSTEXPR14
     T extract() const
     {

From db878c54c598abc90bc543fd9bb9f3b7641f6875 Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Sat, 20 Jan 2024 10:08:15 +0000
Subject: [PATCH 25/26] Fix C++ standard syntax compatibility for repair()

---
 include/etl/circular_buffer.h | 14 +++++---------
 include/etl/deque.h           |  8 +++-----
 include/etl/platform.h        |  9 +++++++++
 include/etl/string.h          | 10 ++++++----
 include/etl/u16string.h       | 10 ++++++----
 include/etl/u32string.h       | 10 ++++++----
 include/etl/u8string.h        | 10 ++++++----
 include/etl/vector.h          | 21 +++++++++++----------
 include/etl/wstring.h         | 10 ++++++----
 9 files changed, 58 insertions(+), 44 deletions(-)

diff --git a/include/etl/circular_buffer.h b/include/etl/circular_buffer.h
index a099ca4a..f57d863d 100644
--- a/include/etl/circular_buffer.h
+++ b/include/etl/circular_buffer.h
@@ -1208,11 +1208,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-    virtual
-#endif
+      virtual void repair() ETL_OVERRIDE
+#else
       void repair()
-#ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-      ETL_OVERRIDE
 #endif
     {
       ETL_ASSERT(etl::is_trivially_copyable<T>::value, ETL_ERROR(etl::circular_buffer_incompatible_type));
@@ -1395,11 +1393,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-    virtual
-#endif
-      void repair()
-#ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/deque.h b/include/etl/deque.h
index 8a11063e..5586360a 100644
--- a/include/etl/deque.h
+++ b/include/etl/deque.h
@@ -2483,11 +2483,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_IDEQUE_REPAIR_ENABLE
-      virtual
-#endif
-      void repair()
-#ifdef ETL_IDEQUE_REPAIR_ENABLE
-      ETL_OVERRIDE
+        virtual void repair() ETL_OVERRIDE
+#else
+        void repair()
 #endif
     {
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
diff --git a/include/etl/platform.h b/include/etl/platform.h
index 360f9027..17c7961d 100644
--- a/include/etl/platform.h
+++ b/include/etl/platform.h
@@ -202,6 +202,14 @@ SOFTWARE.
   #define ETL_HAS_IDEQUE_REPAIR 0
 #endif
 
+//*************************************
+// Option to enable repair-after-memcpy for icircular_buffer.
+#if defined(ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE)
+#define ETL_HAS_ICIRCULAR_BUFFER_REPAIR 1
+#else
+#define ETL_HAS_ICIRCULAR_BUFFER_REPAIR 0
+#endif
+
 //*************************************
 // Indicate if C++ exceptions are enabled.
 #if defined(ETL_THROW_EXCEPTIONS)
@@ -477,6 +485,7 @@ namespace etl
     static ETL_CONSTANT bool has_string_clear_after_use       = (ETL_HAS_STRING_CLEAR_AFTER_USE == 1);
     static ETL_CONSTANT bool has_istring_repair               = (ETL_HAS_ISTRING_REPAIR == 1);
     static ETL_CONSTANT bool has_ivector_repair               = (ETL_HAS_IVECTOR_REPAIR == 1);
+    static ETL_CONSTANT bool has_icircular_buffer_repair      = (ETL_HAS_ICIRCULAR_BUFFER_REPAIR == 1);
     static ETL_CONSTANT bool has_mutable_array_view           = (ETL_HAS_MUTABLE_ARRAY_VIEW == 1);
     static ETL_CONSTANT bool has_ideque_repair                = (ETL_HAS_IDEQUE_REPAIR == 1);
     static ETL_CONSTANT bool has_virtual_messages             = (ETL_HAS_VIRTUAL_MESSAGES == 1);
diff --git a/include/etl/string.h b/include/etl/string.h
index 5f925337..1fbc19d2 100644
--- a/include/etl/string.h
+++ b/include/etl/string.h
@@ -246,9 +246,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::istring::repair_buffer(buffer);
@@ -434,9 +435,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/u16string.h b/include/etl/u16string.h
index 2c100c8b..c0fea3a2 100644
--- a/include/etl/u16string.h
+++ b/include/etl/u16string.h
@@ -230,9 +230,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu16string::repair_buffer(buffer);
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/u32string.h b/include/etl/u32string.h
index 88d0ed44..766a0cbc 100644
--- a/include/etl/u32string.h
+++ b/include/etl/u32string.h
@@ -230,9 +230,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu32string::repair_buffer(buffer);
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/u8string.h b/include/etl/u8string.h
index 9d8b9458..015ef3c1 100644
--- a/include/etl/u8string.h
+++ b/include/etl/u8string.h
@@ -247,9 +247,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu8string::repair_buffer(buffer);
@@ -435,9 +436,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/vector.h b/include/etl/vector.h
index af236dc7..4150c443 100644
--- a/include/etl/vector.h
+++ b/include/etl/vector.h
@@ -1346,11 +1346,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-    virtual
-#endif
+    virtual void repair() ETL_OVERRIDE
+#else
     void repair()
-#ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
 #endif
     {
       ETL_ASSERT_OR_RETURN(etl::is_trivially_copyable<T>::value, ETL_ERROR(etl::vector_incompatible_type));
@@ -1527,9 +1525,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
@@ -1649,9 +1648,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::ivector<T*>::repair_buffer(buffer);
@@ -1806,9 +1806,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::ivector<T*>::repair_buffer(this->p_buffer);
diff --git a/include/etl/wstring.h b/include/etl/wstring.h
index 20ce4ac4..683359de 100644
--- a/include/etl/wstring.h
+++ b/include/etl/wstring.h
@@ -231,9 +231,10 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #if ETL_HAS_ISTRING_REPAIR
-    virtual
-#endif
+    virtual void repair() ETL_OVERRIDE
+#else
     void repair()
+#endif
     {
       etl::iwstring::repair_buffer(buffer);
     }
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }

From 94ee20e2fdd1f8e7a117fb6a4acc518782eb380c Mon Sep 17 00:00:00 2001
From: John Wellbelove <john.wellbelove@etlcpp.com>
Date: Sat, 20 Jan 2024 10:08:15 +0000
Subject: [PATCH 26/26] Fix C++ standard syntax compatibility for repair()

---
 include/etl/circular_buffer.h    | 14 +++++---------
 include/etl/deque.h              |  8 +++-----
 include/etl/platform.h           |  9 +++++++++
 include/etl/private/bitset_new.h |  4 ++--
 include/etl/string.h             | 10 ++++++----
 include/etl/u16string.h          | 10 ++++++----
 include/etl/u32string.h          | 10 ++++++----
 include/etl/u8string.h           | 10 ++++++----
 include/etl/vector.h             | 21 +++++++++++----------
 include/etl/wstring.h            | 10 ++++++----
 10 files changed, 60 insertions(+), 46 deletions(-)

diff --git a/include/etl/circular_buffer.h b/include/etl/circular_buffer.h
index a099ca4a..f57d863d 100644
--- a/include/etl/circular_buffer.h
+++ b/include/etl/circular_buffer.h
@@ -1208,11 +1208,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-    virtual
-#endif
+      virtual void repair() ETL_OVERRIDE
+#else
       void repair()
-#ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-      ETL_OVERRIDE
 #endif
     {
       ETL_ASSERT(etl::is_trivially_copyable<T>::value, ETL_ERROR(etl::circular_buffer_incompatible_type));
@@ -1395,11 +1393,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-    virtual
-#endif
-      void repair()
-#ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/deque.h b/include/etl/deque.h
index 8a11063e..5586360a 100644
--- a/include/etl/deque.h
+++ b/include/etl/deque.h
@@ -2483,11 +2483,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_IDEQUE_REPAIR_ENABLE
-      virtual
-#endif
-      void repair()
-#ifdef ETL_IDEQUE_REPAIR_ENABLE
-      ETL_OVERRIDE
+        virtual void repair() ETL_OVERRIDE
+#else
+        void repair()
 #endif
     {
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
diff --git a/include/etl/platform.h b/include/etl/platform.h
index 360f9027..17c7961d 100644
--- a/include/etl/platform.h
+++ b/include/etl/platform.h
@@ -202,6 +202,14 @@ SOFTWARE.
   #define ETL_HAS_IDEQUE_REPAIR 0
 #endif
 
+//*************************************
+// Option to enable repair-after-memcpy for icircular_buffer.
+#if defined(ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE)
+#define ETL_HAS_ICIRCULAR_BUFFER_REPAIR 1
+#else
+#define ETL_HAS_ICIRCULAR_BUFFER_REPAIR 0
+#endif
+
 //*************************************
 // Indicate if C++ exceptions are enabled.
 #if defined(ETL_THROW_EXCEPTIONS)
@@ -477,6 +485,7 @@ namespace etl
     static ETL_CONSTANT bool has_string_clear_after_use       = (ETL_HAS_STRING_CLEAR_AFTER_USE == 1);
     static ETL_CONSTANT bool has_istring_repair               = (ETL_HAS_ISTRING_REPAIR == 1);
     static ETL_CONSTANT bool has_ivector_repair               = (ETL_HAS_IVECTOR_REPAIR == 1);
+    static ETL_CONSTANT bool has_icircular_buffer_repair      = (ETL_HAS_ICIRCULAR_BUFFER_REPAIR == 1);
     static ETL_CONSTANT bool has_mutable_array_view           = (ETL_HAS_MUTABLE_ARRAY_VIEW == 1);
     static ETL_CONSTANT bool has_ideque_repair                = (ETL_HAS_IDEQUE_REPAIR == 1);
     static ETL_CONSTANT bool has_virtual_messages             = (ETL_HAS_VIRTUAL_MESSAGES == 1);
diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 6d653298..1220ef92 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -492,8 +492,8 @@ namespace etl
 		template <typename T, size_t Position, size_t Length>
 #endif
     ETL_CONSTEXPR14
-      static
-      T extract(const_pointer pbuffer)
+    static
+    T extract(const_pointer pbuffer)
     {
       typedef typename etl::make_unsigned<T>::type unsigned_t;
 
diff --git a/include/etl/string.h b/include/etl/string.h
index 5f925337..1fbc19d2 100644
--- a/include/etl/string.h
+++ b/include/etl/string.h
@@ -246,9 +246,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::istring::repair_buffer(buffer);
@@ -434,9 +435,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/u16string.h b/include/etl/u16string.h
index 2c100c8b..c0fea3a2 100644
--- a/include/etl/u16string.h
+++ b/include/etl/u16string.h
@@ -230,9 +230,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu16string::repair_buffer(buffer);
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/u32string.h b/include/etl/u32string.h
index 88d0ed44..766a0cbc 100644
--- a/include/etl/u32string.h
+++ b/include/etl/u32string.h
@@ -230,9 +230,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu32string::repair_buffer(buffer);
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/u8string.h b/include/etl/u8string.h
index 9d8b9458..015ef3c1 100644
--- a/include/etl/u8string.h
+++ b/include/etl/u8string.h
@@ -247,9 +247,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu8string::repair_buffer(buffer);
@@ -435,9 +436,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/vector.h b/include/etl/vector.h
index af236dc7..4150c443 100644
--- a/include/etl/vector.h
+++ b/include/etl/vector.h
@@ -1346,11 +1346,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-    virtual
-#endif
+    virtual void repair() ETL_OVERRIDE
+#else
     void repair()
-#ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
 #endif
     {
       ETL_ASSERT_OR_RETURN(etl::is_trivially_copyable<T>::value, ETL_ERROR(etl::vector_incompatible_type));
@@ -1527,9 +1525,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
@@ -1649,9 +1648,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::ivector<T*>::repair_buffer(buffer);
@@ -1806,9 +1806,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::ivector<T*>::repair_buffer(this->p_buffer);
diff --git a/include/etl/wstring.h b/include/etl/wstring.h
index 20ce4ac4..683359de 100644
--- a/include/etl/wstring.h
+++ b/include/etl/wstring.h
@@ -231,9 +231,10 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #if ETL_HAS_ISTRING_REPAIR
-    virtual
-#endif
+    virtual void repair() ETL_OVERRIDE
+#else
     void repair()
+#endif
     {
       etl::iwstring::repair_buffer(buffer);
     }
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }