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>;