From eecbd5276fd6fb19ef54974723183de9377ffdae Mon Sep 17 00:00:00 2001 From: John Maddock Date: Wed, 11 Nov 2009 18:57:24 +0000 Subject: [PATCH] Reverted Integer back to Release branch state - as per devel-list discussions. [SVN r57580] --- cstdint.htm | 2 +- doc/integer_mask.html | 209 +----- include/boost/integer.hpp | 383 ++--------- include/boost/integer/integer_mask.hpp | 201 ++---- include/boost/integer_fwd.hpp | 78 +-- include/boost/integer_traits.hpp | 89 ++- integer.htm | 391 ++--------- integer_traits.html | 2 +- test/Jamfile.v2 | 2 +- test/integer_mask_test.cpp | 222 +++---- test/integer_test.cpp | 882 +++++++------------------ test/issue_2134.cpp | 33 - 12 files changed, 619 insertions(+), 1875 deletions(-) delete mode 100644 test/issue_2134.cpp diff --git a/cstdint.htm b/cstdint.htm index 0c2f893..9492827 100644 --- a/cstdint.htm +++ b/cstdint.htm @@ -18,7 +18,7 @@ writing portable code that requires certain integer widths. All typedef's are i header <stdint.h>.  The 64-bit types required by the C standard are not required in the boost header, and may not be supplied in all implementations, because long long is not [yet] included in the C++ standard.

-

See cstdint_test.cpp for a test program.

+

See cstdint_test.cpp for a test program.

Exact-width integer types

The typedef int#_t, with # replaced by the width, designates a signed integer type of exactly # bits; int8_t denotes an 8-bit diff --git a/doc/integer_mask.html b/doc/integer_mask.html index 6dba489..5bc7301 100644 --- a/doc/integer_mask.html +++ b/doc/integer_mask.html @@ -8,11 +8,7 @@

boost.png (6897 bytes)Integer Bit Mask Templates

-

The class templates in <boost/integer/integer_mask.hpp> -provide bit masks for a certain bit position or a contiguous-bit pack of a -certain size. The types of the masking constants come from the integer type selection templates header.

+

The class templates in <boost/integer/integer_mask.hpp> provide bit masks for a certain bit position or a contiguous-bit pack of a certain size. The types of the masking constants come from the integer type selection templates header.

Contents

@@ -21,7 +17,6 @@ href="../integer.htm">integer type selection templates header.

  • Synopsis
  • Single Bit-Mask Class Template
  • Group Bit-Mask Class Template
    • -
  • MPL-Compatible Variants
  • Example
  • Demonstration Program
  • Rationale
    • @@ -31,68 +26,39 @@ href="../integer.htm">integer type selection templates header.

    Synopsis

    -#include <boost/integer_fwd.hpp>  // forwarding header
-#include <boost/integer.hpp>      // for boost::int_fast_t
-#include <cstddef>                // for std::size_t
+#include <cstddef>  // for std::size_t
 
 namespace boost
 {
 
-// MPL-compatible
-template < int Offset >
-struct integer_hi_mask
-{
-    static  bool const  is_specialized = implementation_supplied;
-    static  int const   bit_offset = Offset;
-
-    typedef implementation_supplied  type;
-    typedef implementation_supplied  value_type;
-    static  value_type const  value = implementation_supplied;
-    // There are other (optional) operations....
-};
-
-template < int Length >
-struct integer_lo_mask
-{
-    static  bool const  is_specialized = implementation_supplied;
-    static  int const   bit_count = Length;
-
-    typedef implementation_supplied  type;
-    typedef implementation_supplied  value_type;
-    static  value_type const  value = implementation_supplied;
-    // There are other (optional) operations....
-};
-
-// single
 template < std::size_t Bit >
-class high_bit_mask_t
+struct high_bit_mask_t
 {
-public:
-    typedef typename integer_hi_mask<Bit>::value_type  least;
-    typedef int_fast_t<least>::fast                     fast;
+    typedef implementation_supplied  least;
+    typedef implementation_supplied   fast;
 
-    static const least  high_bit = integer_hi_mask<Bit>::value;
-    static const fast   high_bit_fast = high_bit;
+    static const least  high_bit = implementation_defined;
+    static const fast   high_bit_fast = implementation_defined;
 
     static const std::size_t  bit_position = Bit;
 
 };
 
-// group
 template < std::size_t Bits >
-class low_bits_mask_t
+struct low_bits_mask_t
 {
-public:
-    typedef typename integer_lo_mask<Bits>::value_type  least;
-    typedef int_fast_t<least>::fast                      fast;
+    typedef implementation_supplied  least;
+    typedef implementation_supplied   fast;
 
-    static const least  sig_bits = integer_lo_mask<Bits>::value;
-    static const fast   sig_bits_fast = sig_bits;
+    static const least  sig_bits = implementation_defined;
+    static const fast   sig_bits_fast = implementation_defined;
 
     static const std::size_t  bit_count = Bits;
 
 };
 
+// Specializations for low_bits_mask_t exist for certain bit counts.
+
 }  // namespace boost
    @@ -183,149 +149,16 @@ describes the members of an instantiation of -

    MPL-Compatible Variants

    - -

    The single and group bit-mask class templates have several drawbacks:

    - - - -

    The integer_hi_mask and integer_lo_mask class -templates provide MPL-compatible alternatives. These alternatives have the -form:

    - -
    -template< int Size >
-struct name
-{
-    static  bool const  is_specialized = implementation_supplied;
-    static  int const   switch_id = Size;
-
-    typedef implementation_supplied  type;
-    typedef implementation_supplied  value_type;
-    static  value_type const  value = implementation_supplied;
-    // with other operations...
-};
-
    - -

    Only some of the members are always present. The presence of other members -and operations is flagged by the (always-present) is_specialized.

    - - - - - - - - - - - - - - - -
    Permanent Members of the MPL-Compatible Masking Class Template - Types
    Class Template MemberMeaning
    is_specializedFlag indicating when a particular template class instantiation is a - valid meta-function (true) or not (false).
    switch_id (Actual name is template-specific.)The value of the main control parameter, accessible even if the - template class instantiation is aliased.
    - -

    The optional members are based from inheriting from a MPL-style Integral -Constant type, but only if is_specialized is true.

    - - - - - - - - - - - - - - - - - - - -
    Optional Members of the MPL-Compatible Masking Types
    Class Template MemberMeaning
    valueThe actual bit mask.
    value_typeThe type of the bit mask value.
    typeThe Integral Constant implementation type, which should be - boost::mpl:: - integral_c< value_type, value - >.
    - -

    The Integral Constant prototype also adds the following operations:

    - - - - - - - - - - - - - - - - - - - -
    Optional Operations of the MPL-Compatible Masking Types
    Operation (with n as a masking type)Meaning
    boost::mpl::next< n >::typeboost::mpl::next< n::type >::type, i.e. - boost::mpl::integral_c< n::value_type, n::value + 1 - >.
    boost::mpl::prior< n >::typeboost::mpl::prior< n::type >::type, i.e. - boost::mpl::integral_c< n::value_type, n::value - 1 - >.
    n::value_type const c = n();c is set to n::value.
    - -

    The specifics for each masking class template are:

    - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    Criteria for the MPL-Compatible Masking Types
    - (Everything besides the parameter ID is in name-space - boost except where indicated.)
    Class TemplateParameter Member IDClassic EquivalentValue TypeValueValid Range
    integer_hi_maskbit_offsethigh_bit_mask_tsized_integral < bit_offset + 1, unsigned >2bit_offset0 <= bit_offset < std::numeric_limits< uintmax_t >::digits
    integer_lo_maskbit_countlow_bits_mask_tsized_integral < bit_count, unsigned >2bit_offset - 10 <= bit_count <= std::numeric_limits< uintmax_t >::digits
    +

    Implementation Note
    +When Bits is the exact size of a built-in unsigned type, +the implementation has to change to prevent undefined behavior. +Therefore, there are specializations of low_bits_mask_t at +those bit counts.

    Example

    -#include <boost/integer/integer_mask.hpp>
+#include <boost/integer/integer_mask.hpp>
 
 //...
 
@@ -367,7 +200,7 @@ href="http://www.boost.org/people/daryle_walker.html">Daryle Walker.
    
 
 
    
 
-
    Revised July 29, 2008
    
+
    Revised September 23, 2001
    
 
 
    © Copyright Daryle Walker 2001.  Use, modification, and distribution are
 subject to the Boost Software License, Version 1.0.  (See accompanying file  header. (John Maddock)
 //   30 Jul 00  Add typename syntax fix (Jens Maurer)
@@ -23,357 +17,108 @@
 
 #include   // self include
 
-#include              // for BOOST_STATIC_CONSTANT, etc.
-#include             // for boost::uintmax_t, intmax_t
-#include      // for boost::integer_traits
-#include              // for std::numeric_limits
-#include   // for boost::enable_if_c
-
-#include   // for BOOST_HAS_XINT, etc.
-
-#include   // for UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, etc.
+#include   // for boost::integer_traits
+#include           // for std::numeric_limits
 
 namespace boost
 {
 
-  //  integer template mapping a type to its processor-optimized analog  -----//
-
-  //  Some types can be handled better by the processor than others.  This
-  //  template metafunction should map various built-in integral types to
-  //  the processor's perferred type for the given type's value range
-  template < typename BaseInt >
-  struct fast_integral
-  {
-      typedef BaseInt  type;
-  };
-
-  // Platform-specific specializations should go here.
+  //  Helper templates  ------------------------------------------------------//
 
   //  fast integers from least integers
   //  int_fast_t<> works correctly for unsigned too, in spite of the name.
   template< typename LeastInt >
-  struct int_fast_t { typedef typename fast_integral::type fast; };
+  struct int_fast_t { typedef LeastInt fast; }; // imps may specialize
 
-namespace detail
-{
+  //  convert category to type 
+  template< int Category > struct int_least_helper {}; // default is empty
 
-  //  Helper templates  ------------------------------------------------------//
-
-  //  convert integer category to type ; default is empty
-  template< int Rank, typename Signedness > struct  int_least_helper {};
-
-  //  specializatons: 1=(unsigned) __int64/long long, 2=(unsigned) long,
-  //     3=unsigned/int, 4=(unsigned) short, 5=(un)signed char
-  //  no specializations for 0: requests for a type > (unsigned) (long) long are
-  //     in error
-#if BOOST_HAS_XINT
-  template<> struct int_least_helper<1,   signed>  { typedef  xint_t least; };
-  template<> struct int_least_helper<1, unsigned>  { typedef uxint_t least; };
-#endif
-  template<> struct int_least_helper<2, signed> { typedef long least; };
-  template<> struct int_least_helper<2, unsigned>
-   { typedef unsigned long least; };
-  template<> struct int_least_helper<3, signed> { typedef int least; };
-  template<> struct int_least_helper<3, unsigned>
-   { typedef unsigned int least; };
-  template<> struct int_least_helper<4, signed> { typedef short least; };
-  template<> struct int_least_helper<4, unsigned>
-   { typedef unsigned short least; };
-  template<> struct int_least_helper<5, signed> { typedef signed char least; };
-  template<> struct int_least_helper<5, unsigned>
-   { typedef unsigned char least; };
-
-  //  category bounds
-  enum
-  {
-#if BOOST_HAS_XINT
-      lowest_integral_rank  = 1,
-#else
-      lowest_integral_rank  = 2,
-#endif
-      highest_integral_rank = 5
-  };
-
-  //  map a bit count to a category
-  template < int BitsIncludingSign >
-  struct int_rank_helper
-  {
-      BOOST_STATIC_CONSTANT( int, mantissa = BitsIncludingSign - 1 );
-#if BOOST_HAS_XINT
-      BOOST_STATIC_CONSTANT( int, extended_ = (mantissa <= std::numeric_limits<
-       xint_t >::digits) );
-#else
-      BOOST_STATIC_CONSTANT( int, extended_ = 1 );
-#endif
-      BOOST_STATIC_CONSTANT( int, rank = (BitsIncludingSign > 0) * (extended_ +
-       (mantissa <= std::numeric_limits< long >::digits) +
-       (mantissa <= std::numeric_limits< int >::digits) +
-       (mantissa <= std::numeric_limits< short >::digits) +
-       (mantissa <= std::numeric_limits< signed char >::digits)) );
-  };
-
-  template < int Bits >
-  struct uint_rank_helper
-  {
-#if BOOST_HAS_XINT
-      BOOST_STATIC_CONSTANT( int, extended_ = (Bits <= std::numeric_limits<
-       uxint_t >::digits) );
-#else
-      BOOST_STATIC_CONSTANT( int, extended_ = 1 );
-#endif
-      BOOST_STATIC_CONSTANT( int, rank = (Bits >= 0) * (extended_ +
-       (Bits <= std::numeric_limits< unsigned long >::digits) +
-       (Bits <= std::numeric_limits< unsigned int >::digits) +
-       (Bits <= std::numeric_limits< unsigned short >::digits) +
-       (Bits <= std::numeric_limits< unsigned char >::digits)) );
-  };
-
-  template < int BitsIncludingSign >
-  struct int_exact_rank_helper   { BOOST_STATIC_CONSTANT( int, rank = 0 ); };
-  template < int Bits >
-  struct uint_exact_rank_helper  { BOOST_STATIC_CONSTANT( int, rank = 0 ); };
-
-#define BOOST_PRIVATE_INT_EXACT_BUILDER(Type, Rank) \
-  template < > \
-  struct int_exact_rank_helper::digits + 1> \
-  { BOOST_STATIC_CONSTANT( int, rank = Rank ); }
-#define BOOST_PRIVATE_UINT_EXACT_BUILDER(Type, Rank) \
-  template < > \
-  struct uint_exact_rank_helper::digits> \
-  { BOOST_STATIC_CONSTANT( int, rank = Rank ); }
-
-#if BOOST_HAS_XINT && (BOOST_UXINT_MAX > ULONG_MAX)
-  BOOST_PRIVATE_INT_EXACT_BUILDER( xint_t, 1 );
-  BOOST_PRIVATE_UINT_EXACT_BUILDER( uxint_t, 1 );
-#endif
-#if ULONG_MAX > UINT_MAX
-  BOOST_PRIVATE_INT_EXACT_BUILDER( long, 2 );
-  BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned long, 2 );
-#endif
-#if UINT_MAX > USHRT_MAX
-  BOOST_PRIVATE_INT_EXACT_BUILDER( int, 3 );
-  BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned, 3 );
-#endif
-#if USHRT_MAX > UCHAR_MAX
-  BOOST_PRIVATE_INT_EXACT_BUILDER( short, 4 );
-  BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned short, 4 );
-#endif
-  BOOST_PRIVATE_INT_EXACT_BUILDER( signed char, 5 );
-  BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned char, 5 );
-
-#undef BOOST_PRIVATE_INT_EXACT_BUILDER
-#undef BOOST_PRIVATE_UINT_EXACT_BUILDER
-
-  //  map an extreme value to a category
-  template < intmax_t MaxValue >
-  struct int_max_rank_helper
-  {
-#if BOOST_HAS_XINT
-      BOOST_STATIC_CONSTANT( int, extended_ = (MaxValue <=
-       boost::integer_traits< xint_t >::const_max) );
-#else
-      BOOST_STATIC_CONSTANT( int, extended_ = 1 );
-#endif
-      BOOST_STATIC_CONSTANT( int, rank = (MaxValue > 0) * (extended_ +
-       (MaxValue <= boost::integer_traits< long >::const_max) +
-       (MaxValue <= boost::integer_traits< int >::const_max) +
-       (MaxValue <= boost::integer_traits< short >::const_max) +
-       (MaxValue <= boost::integer_traits< signed char >::const_max)) );
-  };
-
-  template < intmax_t MinValue >
-  struct int_min_rank_helper
-  {
-#if BOOST_HAS_XINT
-      BOOST_STATIC_CONSTANT( int, extended_ = (MinValue >=
-       boost::integer_traits< xint_t >::const_min) );
-#else
-      BOOST_STATIC_CONSTANT( int, extended_ = 1 );
-#endif
-      BOOST_STATIC_CONSTANT( int, rank = (MinValue < 0) * (extended_ +
-       (MinValue >= boost::integer_traits< long >::const_min) +
-       (MinValue >= boost::integer_traits< int >::const_min) +
-       (MinValue >= boost::integer_traits< short >::const_min) +
-       (MinValue >= boost::integer_traits< signed char >::const_min)) );
-  };
-
-  template < uintmax_t Value >
-  struct uint_max_rank_helper
-  {
-#if BOOST_HAS_XINT
-      BOOST_STATIC_CONSTANT( int, extended_ = (Value <= boost::integer_traits<
-       uxint_t >::const_max) );
-#else
-      BOOST_STATIC_CONSTANT( int, extended_ = 1 );
-#endif
-      BOOST_STATIC_CONSTANT( int, rank = extended_ +
-       (Value <= boost::integer_traits< unsigned long >::const_max) +
-       (Value <= boost::integer_traits< unsigned int >::const_max) +
-       (Value <= boost::integer_traits< unsigned short >::const_max) +
-       (Value <= boost::integer_traits< unsigned char >::const_max) );
-  };
-
-  //  convert rank to type, Boost.MPL-style
-  template < int Rank, typename Signedness, class Enable = void >
-  struct integral_rank_to_type
-  {
-      BOOST_STATIC_CONSTANT( bool, is_specialized = false );
-      // No "signed" nor "type" here
-  };
-
-  template < int Rank >
-  struct integral_rank_to_type< Rank, signed, typename
-   enable_if_c<(lowest_integral_rank <= Rank) && (Rank <=
-   highest_integral_rank)>::type >
-  {
-      BOOST_STATIC_CONSTANT( bool, is_specialized = true );
-      BOOST_STATIC_CONSTANT( bool, is_signed = true );
-      typedef typename int_least_helper< Rank, signed >::least  type;
-  };
-
-  template < int Rank >
-  struct integral_rank_to_type< Rank, unsigned, typename
-   enable_if_c<(lowest_integral_rank <= Rank) && (Rank <=
-   highest_integral_rank)>::type >
-  {
-      BOOST_STATIC_CONSTANT( bool, is_specialized = true );
-      BOOST_STATIC_CONSTANT( bool, is_signed = false );
-      typedef typename int_least_helper< Rank, unsigned >::least  type;
-  };
-
-} // namespace detail
-
-  //  MPL-compatible integer-mapping class templates  ------------------------//
-
-  //  minimum number of bits
-  template < int Bits, typename Signedness >
-  struct sized_integral
-  {
-      BOOST_STATIC_CONSTANT( bool, is_specialized = false );
-      BOOST_STATIC_CONSTANT( int, bit_count = Bits );
-  };
-
-  template < int BitsIncludingSign >
-  struct sized_integral< BitsIncludingSign, signed >
-      : detail::integral_rank_to_type<
-         detail::int_rank_helper::rank, signed >
-  {
-      BOOST_STATIC_CONSTANT( int, bit_count = BitsIncludingSign );
-  };
-
-  template < int Bits >
-  struct sized_integral< Bits, unsigned >
-      : detail::integral_rank_to_type<
-         detail::uint_rank_helper::rank, unsigned >
-  {
-      BOOST_STATIC_CONSTANT( int, bit_count = Bits );
-  };
-
-  //  exact number of bits
-  template < int Bits, typename Signedness >
-  struct exact_integral
-  {
-      BOOST_STATIC_CONSTANT( bool, is_specialized = false );
-      BOOST_STATIC_CONSTANT( int, bit_count = Bits );
-  };
-
-  template < int BitsIncludingSign >
-  struct exact_integral< BitsIncludingSign, signed >
-      : detail::integral_rank_to_type<
-         detail::int_exact_rank_helper::rank, signed >
-  {
-      BOOST_STATIC_CONSTANT( int, bit_count = BitsIncludingSign );
-  };
-
-  template < int Bits >
-  struct exact_integral< Bits, unsigned >
-      : detail::integral_rank_to_type<
-         detail::uint_exact_rank_helper::rank, unsigned >
-  {
-      BOOST_STATIC_CONSTANT( int, bit_count = Bits );
-  };
-
-  //  maximum supported (positive) value, signed
-  template < intmax_t MaxValue >
-  struct maximum_signed_integral
-      : detail::integral_rank_to_type<
-         detail::int_max_rank_helper::rank, signed >
-  {
-      BOOST_STATIC_CONSTANT( intmax_t, bound = MaxValue );
-  };
-
-  //  minimum supported (negative) value
-  template < intmax_t MinValue >
-  struct minimum_signed_integral
-      : detail::integral_rank_to_type<
-         detail::int_min_rank_helper::rank, signed >
-  {
-      BOOST_STATIC_CONSTANT( intmax_t, bound = MinValue );
-  };
-
-  //  maximum supported (nonnegative) value, unsigned
-  template < uintmax_t Value >
-  struct maximum_unsigned_integral
-      : detail::integral_rank_to_type<
-         detail::uint_max_rank_helper::rank, unsigned >
-  {
-      BOOST_STATIC_CONSTANT( uintmax_t, bound = Value );
-  };
+  //  specializatons: 1=long, 2=int, 3=short, 4=signed char,
+  //     6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned char
+  //  no specializations for 0 and 5: requests for a type > long are in error
+  template<> struct int_least_helper<1> { typedef long least; };
+  template<> struct int_least_helper<2> { typedef int least; };
+  template<> struct int_least_helper<3> { typedef short least; };
+  template<> struct int_least_helper<4> { typedef signed char least; };
+  template<> struct int_least_helper<6> { typedef unsigned long least; };
+  template<> struct int_least_helper<7> { typedef unsigned int least; };
+  template<> struct int_least_helper<8> { typedef unsigned short least; };
+  template<> struct int_least_helper<9> { typedef unsigned char least; };
 
   //  integer templates specifying number of bits  ---------------------------//
 
   //  signed
-  template< int Bits >   // minimum bits (including sign) required
+  template< int Bits >   // bits (including sign) required
   struct int_t 
   {
-      typedef typename sized_integral::type  least;
-      typedef typename int_fast_t::fast             fast;
-  };
-
-  template< int Bits >   // exact bits (including sign) desired
-  struct int_exact_t
-  {
-      typedef typename exact_integral::type  exact;
+      typedef typename int_least_helper
+        <
+          (Bits-1 <= std::numeric_limits::digits) +
+          (Bits-1 <= std::numeric_limits::digits) +
+          (Bits-1 <= std::numeric_limits::digits) +
+          (Bits-1 <= std::numeric_limits::digits)
+        >::least  least;
+      typedef typename int_fast_t::fast  fast;
   };
 
   //  unsigned
-  template< int Bits >   // minimum bits required
+  template< int Bits >   // bits required
   struct uint_t 
   {
-      typedef typename sized_integral::type  least;
-      typedef typename int_fast_t::fast               fast;
+      typedef typename int_least_helper
+        < 
+          5 +
+          (Bits <= std::numeric_limits::digits) +
+          (Bits <= std::numeric_limits::digits) +
+          (Bits <= std::numeric_limits::digits) +
+          (Bits <= std::numeric_limits::digits)
+        >::least  least;
+      typedef typename int_fast_t::fast  fast;
       // int_fast_t<> works correctly for unsigned too, in spite of the name.
   };
 
-  template< int Bits >   // exact bits desired
-  struct uint_exact_t
-  {
-      typedef typename exact_integral::type  exact;
-  };
-
   //  integer templates specifying extreme value  ----------------------------//
 
   //  signed
-  template< intmax_t MaxValue >   // maximum value to require support
+  template< long MaxValue >   // maximum value to require support
   struct int_max_value_t 
   {
-      typedef typename maximum_signed_integral::type  least;
-      typedef typename int_fast_t::fast                  fast;
+      typedef typename int_least_helper
+        <
+          (MaxValue <= integer_traits::const_max) +
+          (MaxValue <= integer_traits::const_max) +
+          (MaxValue <= integer_traits::const_max) +
+          (MaxValue <= integer_traits::const_max)
+        >::least  least;
+      typedef typename int_fast_t::fast  fast;
   };
 
-  template< intmax_t MinValue >   // minimum value to require support
+  template< long MinValue >   // minimum value to require support
   struct int_min_value_t 
   {
-      typedef typename minimum_signed_integral::type  least;
-      typedef typename int_fast_t::fast                  fast;
+      typedef typename int_least_helper
+        <
+          (MinValue >= integer_traits::const_min) +
+          (MinValue >= integer_traits::const_min) +
+          (MinValue >= integer_traits::const_min) +
+          (MinValue >= integer_traits::const_min)
+        >::least  least;
+      typedef typename int_fast_t::fast  fast;
   };
 
   //  unsigned
-  template< uintmax_t Value >   // maximum value to require support
+  template< unsigned long Value >   // maximum value to require support
   struct uint_value_t 
   {
-      typedef typename maximum_unsigned_integral::type  least;
-      typedef typename int_fast_t::fast                 fast;
+      typedef typename int_least_helper
+        < 
+          5 +
+          (Value <= integer_traits::const_max) +
+          (Value <= integer_traits::const_max) +
+          (Value <= integer_traits::const_max) +
+          (Value <= integer_traits::const_max)
+        >::least  least;
+      typedef typename int_fast_t::fast  fast;
   };
 
 
diff --git a/include/boost/integer/integer_mask.hpp b/include/boost/integer/integer_mask.hpp
index a334d64..0a092d3 100644
--- a/include/boost/integer/integer_mask.hpp
+++ b/include/boost/integer/integer_mask.hpp
@@ -12,192 +12,81 @@
 
 #include   // self include
 
-#include              // for BOOST_STATIC_CONSTANT
-#include             // for boost::uintmax_t
-#include             // for boost::sized_integral
-#include              // for std::numeric_limits
-#include             // for boost::mpl::and_
-#include         // for boost::mpl::bitor_, shift_left
-#include            // for boost::mpl::true_
-#include      // for boost::mpl::greater_equal, etc.
-#include      // for boost::mpl::empty_base
-#include              // for boost::mpl::if_
-#include             // for boost::mpl::int_
-#include      // for boost::integral_c
-#include      // for boost::mpl::next, prior
-#include   // for boost::enable_if
+#include    // for BOOST_STATIC_CONSTANT
+#include   // for boost::uint_t
 
+#include   // for UCHAR_MAX, etc.
 #include   // for std::size_t
 
+#include   // for std::numeric_limits
+
 
 namespace boost
 {
-namespace detail
-{
-
-//  Helper templates  --------------------------------------------------------//
-
-template < int Bits >
-struct hi_integer_mask_builder1
-{
-    typedef boost::mpl::int_  bit_count_type;
-
-    typedef typename boost::mpl::next::type
-      mask_length_type;
-    typedef boost::sized_integral
-      mask_type;
-
-    typedef boost::mpl::integral_c  one_type;
-    typedef boost::mpl::shift_left  result_type;
-};
-
-template < int Bits >
-struct hi_integer_mask_builder2
-{
-    typedef boost::mpl::int_  bit_count_type;
-
-    typedef boost::mpl::greater_equal< bit_count_type, boost::mpl::int_<0> >
-      lo_bound_type;
-    typedef boost::mpl::less< bit_count_type,
-     boost::mpl::int_::digits> >
-      hi_bound_type;
-    typedef boost::mpl::and_  count_valid_type;
-};
-
-template < int Bits, class Enable = void >
-struct hi_integer_mask_builder3
-{
-    BOOST_STATIC_CONSTANT( bool, is_specialized = false );
-};
-
-template < int Bits >
-struct hi_integer_mask_builder3< Bits, typename boost::enable_if::count_valid_type>::type >
-    : hi_integer_mask_builder1::result_type
-{
-    BOOST_STATIC_CONSTANT( bool, is_specialized = true );
-};
-
-template < int Bits >
-struct lo_integer_mask_builder1
-{
-    typedef boost::mpl::int_  bit_count_type;
-
-    typedef typename boost::mpl::prior::type
-      shift_length_type;
-    typedef boost::sized_integral
-      mask_type;
-
-    typedef boost::mpl::integral_c  one_type;
-    typedef boost::mpl::shift_left
-      high_bit_type;
-    typedef typename boost::mpl::prior::type  low_bits_type;
-    typedef boost::mpl::bitor_  result_type;
-};
-
-template <  >
-struct lo_integer_mask_builder1< 0 >
-{
-    // Let's not deal with negative interim values....
-    typedef boost::mpl::integral_c  result_type;
-};
-
-template < int Bits >
-struct lo_integer_mask_builder2
-{
-    typedef boost::mpl::int_  bit_count_type;
-
-    typedef boost::mpl::greater_equal< bit_count_type, boost::mpl::int_<0> >
-      lo_bound_type;
-    typedef boost::mpl::less_equal< bit_count_type,
-     boost::mpl::int_::digits> >
-      hi_bound_type;
-    typedef boost::mpl::and_  count_valid_type;
-};
-
-template <  >
-struct lo_integer_mask_builder2< 0 >
-{
-    typedef boost::mpl::true_  count_valid_type;
-};
-
-template < int Bits, class Enable = void >
-struct lo_integer_mask_builder3
-{
-    BOOST_STATIC_CONSTANT( bool, is_specialized = false );
-    // No MPL Integral Constant to inherit from
-};
-
-template < int Bits >
-struct lo_integer_mask_builder3< Bits, typename enable_if::count_valid_type>::type >
-    : lo_integer_mask_builder1::result_type
-{
-    BOOST_STATIC_CONSTANT( bool, is_specialized = true );
-};
-
-} // namespace detail
-
-
-//  MPL-compatible integer mask class templates  -----------------------------//
-
-// Displaced single-bit mask, 1 << Offset, 0 <= Offset < BitLengthOf(uintmax_t)
-template < int Offset >
-struct integer_hi_mask
-    : detail::hi_integer_mask_builder3
-{
-    BOOST_STATIC_CONSTANT( int, bit_offset = Offset );
-};
-
-// Lowest bit-group mask, 2**Length - 1, 0 <= Length <= BitLengthOf(uintmax_t)
-template < int Length >
-struct integer_lo_mask
-    : detail::lo_integer_mask_builder3
-{
-    BOOST_STATIC_CONSTANT( int, bit_count = Length );
-};
 
 
 //  Specified single-bit mask class declaration  -----------------------------//
 //  (Lowest bit starts counting at 0.)
 
 template < std::size_t Bit >
-class high_bit_mask_t
+struct high_bit_mask_t
 {
-    typedef integer_hi_mask  impl_type;
+    typedef typename uint_t<(Bit + 1)>::least  least;
+    typedef typename uint_t<(Bit + 1)>::fast   fast;
 
-public:
-    typedef typename impl_type::value_type   least;
-    typedef typename int_fast_t::fast  fast;
+    BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << Bit) );
+    BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << Bit) );
 
-    BOOST_STATIC_CONSTANT( least, high_bit = impl_type::value );
-    BOOST_STATIC_CONSTANT( fast, high_bit_fast = impl_type::value );
-
-    BOOST_STATIC_CONSTANT( std::size_t, bit_position = impl_type::bit_offset );
+    BOOST_STATIC_CONSTANT( std::size_t, bit_position = Bit );
 
 };  // boost::high_bit_mask_t
 
 
 //  Specified bit-block mask class declaration  ------------------------------//
 //  Makes masks for the lowest N bits
+//  (Specializations are needed when N fills up a type.)
 
 template < std::size_t Bits >
-class low_bits_mask_t
+struct low_bits_mask_t
 {
-    typedef integer_lo_mask  impl_type;
+    typedef typename uint_t::least  least;
+    typedef typename uint_t::fast   fast;
 
-public:
-    typedef typename impl_type::value_type   least;
-    typedef typename int_fast_t::fast  fast;
+    BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
+    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
 
-    BOOST_STATIC_CONSTANT( least, sig_bits = impl_type::value );
-    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = impl_type::value );
-
-    BOOST_STATIC_CONSTANT( std::size_t, bit_count = impl_type::bit_count );
+    BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
 
 };  // boost::low_bits_mask_t
 
 
+#define BOOST_LOW_BITS_MASK_SPECIALIZE( Type )                                  \
+  template <  >  struct low_bits_mask_t< std::numeric_limits::digits >  { \
+      typedef std::numeric_limits           limits_type;                  \
+      typedef uint_t::least  least;                        \
+      typedef uint_t::fast   fast;                         \
+      BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) );              \
+      BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );            \
+      BOOST_STATIC_CONSTANT( std::size_t, bit_count = limits_type::digits );    \
+  }
+
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned char );
+
+#if USHRT_MAX > UCHAR_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned short );
+#endif
+
+#if UINT_MAX > USHRT_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned int );
+#endif
+
+#if ULONG_MAX > UINT_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned long );
+#endif
+
+#undef BOOST_LOW_BITS_MASK_SPECIALIZE
+
+
 }  // namespace boost
 
 
diff --git a/include/boost/integer_fwd.hpp b/include/boost/integer_fwd.hpp
index 3ece2e3..33cfc99 100644
--- a/include/boost/integer_fwd.hpp
+++ b/include/boost/integer_fwd.hpp
@@ -9,12 +9,11 @@
 #ifndef BOOST_INTEGER_FWD_HPP
 #define BOOST_INTEGER_FWD_HPP
 
+#include   // for UCHAR_MAX, etc.
 #include   // for std::size_t
 
-#include    // for BOOST_NO_INTRINSIC_WCHAR_T, etc.
-#include   // for boost::uintmax_t, intmax_t
-
-#include   // for BOOST_HAS_XINT, etc.
+#include   // for BOOST_NO_INTRINSIC_WCHAR_T
+#include   // for std::numeric_limits
 
 
 namespace boost
@@ -25,13 +24,6 @@ namespace boost
 
 // Only has typedefs or using statements, with #conditionals
 
-// ALERT: the forward declarations of items in  need items
-// from this header.  That means that  cannot #include this
-// forwarding header, to avoid infinite recursion!  One day, maybe
-// boost::uintmax_t and boost::intmax_t could be segregated into their own
-// header file (which can't #include this header),  will use
-// that header, and  could refer to .
-
 
 //  From   -----------------------------------------//
 
@@ -73,73 +65,61 @@ template <  >
 template <  >
     class integer_traits< unsigned long >;
 
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && BOOST_HAS_XINT
+#ifdef ULLONG_MAX
 template <  >
-    class integer_traits< ::boost::detail::xint_t >;
+    class integer_traits<  ::boost::long_long_type>;
 
 template <  >
-    class integer_traits< ::boost::detail::uxint_t >;
+    class integer_traits<  ::boost::ulong_long_type >;
 #endif
 
 
 //  From   ------------------------------------------------//
 
-template < typename BaseInt >
-    struct fast_integral;
-
 template < typename LeastInt >
     struct int_fast_t;
 
-template < int Bits, typename Signedness >
-    struct sized_integral;
-
-template < int Bits, typename Signedness >
-    struct exact_integral;
-
-template < intmax_t MaxValue >
-    struct maximum_signed_integral;
-
-template < intmax_t MinValue >
-    struct minimum_signed_integral;
-
-template < uintmax_t Value >
-    struct maximum_unsigned_integral;
-
 template< int Bits >
     struct int_t;
 
-template< int Bits >
-    struct int_exact_t;
-
 template< int Bits >
     struct uint_t;
 
-template< int Bits >
-    struct uint_exact_t;
-
-template< intmax_t MaxValue >
+template< long MaxValue >
     struct int_max_value_t;
 
-template< intmax_t MinValue >
+template< long MinValue >
     struct int_min_value_t;
 
-template< uintmax_t Value >
+template< unsigned long Value >
     struct uint_value_t;
 
 
 //  From   -----------------------------------//
 
-template < int Offset >
-    struct integer_hi_mask;
-
-template < int Length >
-    struct integer_lo_mask;
-
 template < std::size_t Bit >
-    class high_bit_mask_t;
+    struct high_bit_mask_t;
 
 template < std::size_t Bits >
-    class low_bits_mask_t;
+    struct low_bits_mask_t;
+
+template <  >
+    struct low_bits_mask_t< ::std::numeric_limits::digits >;
+
+#if USHRT_MAX > UCHAR_MAX
+template <  >
+    struct low_bits_mask_t< ::std::numeric_limits::digits >;
+#endif
+
+#if UINT_MAX > USHRT_MAX
+template <  >
+    struct low_bits_mask_t< ::std::numeric_limits::digits >;
+#endif
+
+#if ULONG_MAX > UINT_MAX
+template <  >
+    struct low_bits_mask_t< ::std::numeric_limits::digits >;
+#endif
 
 
 //  From   ------------------------------------//
diff --git a/include/boost/integer_traits.hpp b/include/boost/integer_traits.hpp
index 9be25ce..96b3526 100644
--- a/include/boost/integer_traits.hpp
+++ b/include/boost/integer_traits.hpp
@@ -27,8 +27,6 @@
 #include 
 #endif
 
-#include   // for BOOST_HAS_XINT, etc.
-
 
 namespace boost {
 template
@@ -157,28 +155,77 @@ class integer_traits
     public detail::integer_traits_base
 { };
 
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && BOOST_HAS_XINT
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T)
+#if defined(ULLONG_MAX) && defined(BOOST_HAS_LONG_LONG)
 
-#if defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 3)))
-// 
-// The following code emits warnings when built with -pedantic, and there appears
-// to be no other way of suppressing these warnings as use of __extension__ has no 
-// effect, so declare the rest of this header a system header.
+template<>
+class integer_traits< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, LLONG_MIN, LLONG_MAX>
+{ };
+
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULLONG_MAX>
+{ };
+
+#elif defined(ULONG_LONG_MAX) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits< ::boost::long_long_type>  : public std::numeric_limits< ::boost::long_long_type>,    public detail::integer_traits_base< ::boost::long_long_type, LONG_LONG_MIN, LONG_LONG_MAX>{ };
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONG_LONG_MAX>
+{ };
+
+#elif defined(ULONGLONG_MAX) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, LONGLONG_MIN, LONGLONG_MAX>
+{ };
+
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONGLONG_MAX>
+{ };
+
+#elif defined(_LLONG_MAX) && defined(_C2) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, -_LLONG_MAX - _C2, _LLONG_MAX>
+{ };
+
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, _ULLONG_MAX>
+{ };
+
+#elif defined(BOOST_HAS_LONG_LONG)
 //
-#  pragma GCC system_header
+// we have long long but no constants, this happens for example with gcc in -ansi mode,
+// we'll just have to work out the values for ourselves (assumes 2's compliment representation):
+//
+template<>
+class integer_traits< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, (1LL << (sizeof(::boost::long_long_type) - 1)), ~(1LL << (sizeof(::boost::long_long_type) - 1))>
+{ };
+
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ~0uLL>
+{ };
+
 #endif
-
-template<>
-class integer_traits< detail::xint_t >
-  : public std::numeric_limits< detail::xint_t >,
-    public detail::integer_traits_base< detail::xint_t, BOOST_XINT_MIN, BOOST_XINT_MAX >
-{ };
-
-template<>
-class integer_traits< detail::uxint_t >
-  : public std::numeric_limits< detail::uxint_t >,
-    public detail::integer_traits_base< detail::uxint_t, 0u, BOOST_UXINT_MAX >
-{ };
 #endif
 
 } // namespace boost
diff --git a/integer.htm b/integer.htm
index 0130d7a..3d3f9c5 100644
--- a/integer.htm
+++ b/integer.htm
@@ -21,9 +21,8 @@ is particularly useful for solving generic programming problems.
    
 
      
 	
    • Contents
      • 
 	
    • Synopsis
      • 
-	
    • Processor-Optimized Types
      • 
+	
    • Easiest-to-Manipulate Types
      • 
 	
    • Sized Types
      • 
-	
    • MPL-Compatible Variants
      • 
 	
    • Example
      • 
 	
    • Demonstration Program
      • 
 	
    • Rationale
      • 
@@ -33,145 +32,67 @@ is particularly useful for solving generic programming problems.
      
 
 
      Synopsis
      
 
-
      -#include <boost/integer_fwd.hpp>  // forwarding header
-#include <boost/cstdint.hpp>      // for boost::uintmax_t, intmax_t
-
-namespace boost
+
      namespace boost
 {
   //  fast integers from least integers
-  template< typename BaseInt >
-  struct fast_integral
-  {
-      typedef implementation_supplied  type;
-  };
-
   template< typename LeastInt >
   struct int_fast_t
   {
-      typedef typename fast_integral<LeastInt>::type  fast;
-  };
-
-  //  MPL-compatible
-  template< int Bits, typename Signedness >
-  struct sized_integral
-  {
-      static  bool const  is_specialized = implementation_supplied;
-      static  bool const  is_signed = implementation_supplied;
-      static  int const   bit_count = Bits;
-
-      typedef implementation_supplied  type;
-  };
-
-  template< int Bits, typename Signedness >
-  struct exact_integral
-  {
-      static  bool const  is_specialized = implementation_supplied;
-      static  bool const  is_signed = implementation_supplied;
-      static  int const   bit_count = Bits;
-
-      typedef implementation_supplied  type;
-  };
-
-  template< intmax_t MaxValue >
-  struct maximum_signed_integral
-  {
-      static  bool const      is_specialized = implementation_supplied;
-      static  bool const      is_signed = true;
-      static  intmax_t const  bound = MaxValue;
-
-      typedef implementation_supplied  type;
-  };
-
-  template< intmax_t MinValue >
-  struct minimum_signed_integral
-  {
-      static  bool const      is_specialized = implementation_supplied;
-      static  bool const      is_signed = true;
-      static  intmax_t const  bound = MinValue;
-
-      typedef implementation_supplied  type;
-  };
-
-  template< uintmax_t Value >
-  struct maximum_unsigned_integral
-  {
-      static  bool const       is_specialized = implementation_supplied;
-      static  bool const       is_signed = false;
-      static  uintmax_t const  bound = Value;
-
-      typedef implementation_supplied  type;
+      typedef implementation_supplied  fast;
   };
 
   //  signed
   template< int Bits >
   struct int_t 
   {
-      typedef typename sized_integral<Bits, signed>::type  least;
-      typedef int_fast_t<least>::fast                      fast;
-  };
-
-  template< int Bits >
-  struct int_exact_t
-  {
-      typedef typename exact_integral<Bits, signed>::type  exact;
+      typedef implementation_supplied  least;
+      typedef int_fast_t<least>::fast  fast;
   };
 
   //  unsigned
   template< int Bits >
   struct uint_t 
   {
-      typedef typename sized_integral<Bits, unsigned>::type  least;
-      typedef int_fast_t<least>::fast                        fast;
-  };
-
-  template< int Bits >
-  struct uint_exact_t
-  {
-      typedef typename exact_integral<Bits, unsigned>::type  exact;
+      typedef implementation_supplied  least;
+      typedef int_fast_t<least>::fast  fast;
   };
 
   //  signed
-  template< intmax_t MaxValue >
+  template< long MaxValue >
   struct int_max_value_t 
   {
-      typedef typename maximum_signed_integral<MaxValue>::type  least;
-      typedef int_fast_t<least>::fast                           fast;
+      typedef implementation_supplied  least;
+      typedef int_fast_t<least>::fast  fast;
   };
 
-  template< intmax_t MinValue >
+  template< long MinValue >
   struct int_min_value_t 
   {
-      typedef typename minimum_signed_integral<MinValue>::type  least;
-      typedef int_fast_t<least>::fast                           fast;
+      typedef implementation_supplied  least;
+      typedef int_fast_t<least>::fast  fast;
   };
 
   //  unsigned
-  template< uintmax_t Value >
+  template< unsigned long Value >
   struct uint_value_t 
   {
-      typedef typename maximum_unsigned_integral<Value>::type  least;
-      typedef int_fast_t<least>::fast                          fast;
+      typedef implementation_supplied  least;
+      typedef int_fast_t<least>::fast  fast;
   };
 } // namespace boost
 
      
 
-
      Processor-Optimized Types
      
+
      Easiest-to-Manipulate Types
      
 
-
      The fast_integral class template maps its input type to the
+
      The int_fast_t class template maps its input type to the
 next-largest type that the processor can manipulate the easiest, or to
 itself if the input type is already an easy-to-manipulate type.  For
 instance, processing a bunch of char objects may go faster
 if they were converted to int objects before processing. 
-The input type, passed as the only template parameter, can be any built-in
-integral type besides bool.  The output type is given as the class
-member type.
      
-
-
      The int_fast_t class template is the classic meta-function for
-this operation.  Despite the name, it works for unsigned integral types just
-like it works for the signed integral types.  The output type is given as the
-class member fast, defined to be the same as the corresponding
-result from the fast_integral meta-function.
      
+The input type, passed as the only template parameter, must be a
+built-in integral type, except bool.  Unsigned integral
+types can be used, as well as signed integral types, despite the name. 
+The output type is given as the class member fast.
      
 
 
      Implementation Notes
      
 By default, the output type is identical to the input type.  Eventually,
@@ -183,286 +104,72 @@ type.
      
 
 
      Sized Types
      
 
-
      The int_t, int_exact_t, uint_t,
-uint_exact_t, int_max_value_t,
-int_min_value_t, and uint_value_t class templates find
-the most appropriate built-in integral type for the given template parameter.
-This type is given by the class member least or exact.
-For the non-exact class templates, the easiest-to-manipulate version of that
-type is given by the class member fast.  The following table
-describes each template's criteria.
      
+
      The int_t, uint_t,
+int_max_value_t, int_min_value_t, and
+uint_value_t class templates find the most appropiate
+built-in integral type for the given template parameter.  This type is
+given by the class member least.  The easiest-to-manipulate
+version of that type is given by the class member fast. 
+The following table describes each template's criteria.
      
 
-
+
      
-		
+		
-		
+		
+			long.
-		
-		
-	
-	
-		
+		
+			the given number of bits.  The parameter should be a positive
+			number.  A compile-time error results if the parameter is
+			larger than the number of bits in an unsigned
+			long.
-		
-		
-	
-	
-		
+		
-		
+		
-		
+		
      
 	Criteria for the Sized Type Class Templates
 	
      Class Template (all in name-space boost)Class Template
 		Template Parameter Mapping
 	
      
 	
      int_tboost::int_t
 		The smallest built-in signed integral type with at least the
 			given number of bits, including the sign bit.  The parameter
-			must be a positive number.  A compile-time error results if
+			should be a positive number.  A compile-time error results if
 			the parameter is larger than the number of bits in a
-			boost::intmax_t.
 	
      
 	
      int_exact_tThe smallest built-in signed integral type with exactly the
-			given number of bits, including the sign bit.  A compile-time error
-			results if no qualifying type exists.
      uint_tboost::uint_t
 		The smallest built-in unsigned integral type with at least
-			the given number of bits.  The parameter must be a
-			non-negative number.  A compile-time error results if the parameter
-			is larger than the number of bits in a
-			boost::uintmax_t.
 	
      
 	
      uint_exact_tThe smallest built-in unsigned integral type with exactly the given
-			number of bits.  A compile-time error results if no qualifying type
-			exists.
      int_max_value_tboost::int_max_value_t
 		The smallest built-in signed integral type that supports the
-			given value as a maximum.  The parameter must be a
+			given value as a maximum.  The parameter should be a
 			positive number.
 	
      
 	
      int_min_value_tboost::int_min_value_t
 		The smallest built-in signed integral type that supports the
-			given value as a minimum.  The parameter must be a
+			given value as a minimum.  The parameter should be a
 			negative number.
 	
      
 	
      uint_value_tboost::uint_value_t
 		The smallest built-in unsigned integral type that supports
 			the given value as a maximum.  The parameter should be a
 			positive number.
 	
      
 
      
 
-
      MPL-Compatible Variants
      
-
-
      The bit-length sized-type class templates have several drawbacks:
      
-
-
        
-	
      • You must know the valid bit-lengths in advance.
        • 
-	
      • There is no way to inspect the parameter used after a size-type template
-	    class is aliased.
        • 
-	
      • Using an inappropriate parameter value results in a compiler
-	    diagnostic.
        • 
-	
      • The type names used are inconsistent with other transformations in
-	    Boost, like in MPL.
        • 
-	
      • The above two facts make use of the size-type class templates
-	    incompatible with template meta-programming techniques.
        • 
-
      
-
-
      The sized_integral, exact_integral,
-maximum_signed_integral, minimum_signed_integral, and
-maximum_unsigned_integral class templates provide MPL-compatible
-alternatives.  These alternatives generally have the form:
      
-
-
      -template< SwitchType SwitchValue, typename Signedness >
-struct name
-{
-    static  bool const         is_specialized = implementation_supplied;
-    static  bool const         is_signed = implementation_supplied;
-    static  SwitchType const   switch_id = SwitchValue;
-
-    typedef implementation_supplied  type;
-};
-
      
-
-
      Each member, if present, is defined by:
      
-
-
-	
-	
-		
-		
-		
-	
-	
-		
-		
-		
-	
-	
-		
-		
-		
-	
-	
-		
-		
-		
-	
-	
-		
-		
-		
-	
-
      Members in MPL-Compatible Class Templates
      Class Template MemberWhen DefinedMeaning
      is_specializedAlwaysFlag indicating when a particular template class instantiation is a
-		    valid meta-function (true) or not (false).
      is_signedis_specialized == trueFlag indicating whether the signed-variant (true) or
-		    the unsigned-variant (false) of the meta-function is
-		    used.  This is controlled by the Signedness template
-		    parameter:
-		    
-		    	
-		    	
-		    		
-		    		
-		    	
-		    	
-		    		
-		    		
-		    	
-		    	
-		    		
-		    		
-		    	
-		    	
-		    		
-		    		
-		    	
-		    
      Effect of Signedness Setting
      Signedness Typeis_signed
      signedtrue
      unsignedfalse
      anything elsenot defined
      
-		    The type used is a programmer mnemonic; the compiler cannot prevent
-		    someone from using int or signed int
-		    instead of signed, or unsigned int instead
-		    of unsigned.
      switch_id (Actual name is template-specific.)AlwaysThe value of the main control parameter, accessible even if the
-			template class instantiation is aliased.
      typeis_specialized == trueThe meta-function's result.  It appears only if the input parameters
-			satisfy the template's requirements.  Its presence, or lack thereof,
-			enables "Substitution Failure Is Not An Error" (SFINAE)
-			techniques, instead of a hard compiler diagnostic.
      
-
-
      The exceptions are the extreme-value class templates
-(maximum_signed_integral, minimum_signed_integral, and
-maximum_unsigned_integral), which do not take a Signedness
-template parameter because the meta-functions already inherently have signedness.
-
-
      The following table describes each template's criteria.  The classic signed
-and unsigned equivalents are the sized-type class templates that each
-MPL-compatible class template emulates.  (The setting of Signedness
-controls the appropriate emulation.)
      
-
-
-	
-	
-		
-		
-		
-		
-		
-	
-	
-		
-		
-	
-	
-		
-		
-		
-		
-		
-		
-	
-	
-		
-		
-		
-		
-		
-		
-	
-	
-		
-		
-		
-		
-		
-		
-	
-	
-		
-		
-		
-		
-		
-	
-	
-		
-		
-		
-		
-		
-	
-
      Criteria for the MPL-Compatible Class Templates
      Class Template (all in name-space boost)Parameter Type (in name-space boost as needed)Parameter Member IDClassic EquivalentTemplate Parameter Mapping (when type is defined)
      SignedUnsigned
      sized_integralintbit_countint_tuint_tThe smallest built-in integral type with at least
-			bit_count bits (including the sign bit when
-			Signedness is signed).  Not present if no
-			type qualifies.
      exact_integralintbit_countint_exact_tuint_exact_tThe smallest built-in integral type with exactly
-			bit_count bits (including the sign bit when
-			Signedness is signed).  Not present if no
-			type qualifies.
      maximum_signed_integralintmax_tboundint_max_value_tThe smallest built-in integral type that can perserve the value in
-			bound.  Not present if bound is non-positive.It is possible for a type to be absent if
-			a platform supports really-extended integral types (beyond long
-			long or __int64), support for those types goes
-			into <boost/cstdint.hpp>,
-			but said support hadn't yet been added to <boost/integer.hpp>
      minimum_signed_integralintmax_tboundint_min_value_tThe smallest built-in integral type that can perserve the value in
-			bound.  Not present if bound is non-negative.
      maximum_unsigned_integraluintmax_tbounduint_value_tThe smallest built-in integral type that can perserve the value in
-			bound.  Should always be present.
      
-
 
      Example
      
 
-
      -#include <boost/integer.hpp>
-#include <boost/mpl/int.hpp>
-#include <iostream>
-#include <ostream>
-
-//...
-
-template < int Bits >
-bool
-fit_exactly( boost::mpl::int_<Bits> const &x,
- typename boost::exact_integral<Bits, signed>::type *unused = 0 )
-{
-    return true;
-}
-
-template < typename T >
-bool
-fit_exactly( T const &x )
-{
-    return false;
-}
+
      #include <boost/integer.hpp>
 
 //...
 
 int main()
 {
-    typedef boost::mpl::int_<24>  twenty_four;
-
-    boost::int_t<twenty_four::value>::least my_var;
-
-    //...
-
-    std::cout << "my_var " << ( fit_exactly(twenty_four()) ? "does" :
-     "does not" ) << " fit its type exactly." << std::endl;
-
+    boost::int_t<24>::least my_var;
     //...
 }
 
      
 
 
      Demonstration Program
      
 
-
      The program integer_test.cpp is a
+
      The program integer_test.cpp is a
 simplistic demonstration of the results from instantiating various
 examples of the sized type class templates.
      
 
@@ -491,11 +198,11 @@ to Valentin Bonnard and
  Kevlin Henney for sharing
 their designs for similar templates.  Daryle Walker designed the
-exact and value-based sized templates, and the MPL-compatible templates.
      
+value-based sized templates.
      
 
 
      
 
-
      Revised July 16, 2008
      
+
      Revised May 20, 2001
      
 
 
      © Copyright Beman Dawes 1999.  Use, modification, and distribution are
 subject to the Boost Software License, Version 1.0.  (See accompanying file 
 
 
      
 
-The program integer_traits_test.cpp
+The program integer_traits_test.cpp
 exercises the integer_traits class.
 
 
      Acknowledgements
      
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index 50fceee..1609bf5 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -16,5 +16,5 @@ test-suite integer
             /boost/test//boost_test_exec_monitor/static ]
         [ run static_min_max_test.cpp
             /boost/test//boost_test_exec_monitor/static ]
-        [ compile issue_2134.cpp ]
+#        [ compile issue_2134.cpp ]
     ;
diff --git a/test/integer_mask_test.cpp b/test/integer_mask_test.cpp
index c3a0854..38f5211 100644
--- a/test/integer_mask_test.cpp
+++ b/test/integer_mask_test.cpp
@@ -8,149 +8,103 @@
 //  See http://www.boost.org for most recent version including documentation.
 
 //  Revision History
-//  29 Jul 2008  Added MPL-compatible variants of the integer-mask templates.
-//               (Daryle Walker)
-//  27 Jul 2008  Changed tests to use the unit-test system; added
-//               extended-integer support. (Daryle Walker)
 //  23 Sep 2001  Initial version (Daryle Walker)
 
-#define BOOST_TEST_MODULE  "Integer mask tests"
-#include   // unit testing framework
+#include   // for main
 
-#include                // for boost::uintmax_t
+#include                // for boost::exit_success
 #include   // for boost::high_bit_mask_t, etc.
-#include                 // for std::numeric_limits
-#include             // for BOOST_MPL_ASSERT_RELATION,etc.
-#include               // for boost::mpl::bool_
-#include            // for boost::mpl::bitor_, shift_left
-#include           // for boost::mpl::equal_to
-#include                // for boost::mpl::int_
-#include         // for boost::mpl::integral_c
-#include         // for boost::mpl::prior
-#include            // for boost::mpl::range_c
 
-#include    // for std::size_t
-#include        // for std::hex
+#include   // for std::cout (std::endl indirectly)
 
 
-// Custom types/templates, helper functions, and objects
-namespace
+#define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_CHECK( ::boost::high_bit_mask_t< \
+ (v) >::high_bit == (1ul << (v)) );
+#define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_CHECK( ::boost::high_bit_mask_t< \
+ (v) >::high_bit_fast == (1ul << (v)) );
+#define PRIVATE_HIGH_BIT_TEST(v)  do { PRIVATE_HIGH_BIT_SLOW_TEST(v); \
+ PRIVATE_HIGH_BIT_FAST_TEST(v); } while (false)
+
+#define PRIVATE_LOW_BITS_SLOW_TEST(v)  BOOST_CHECK( ::boost::low_bits_mask_t< \
+ (v) >::sig_bits == ((1ul << (v)) - 1) );
+#define PRIVATE_LOW_BITS_FAST_TEST(v)  BOOST_CHECK( ::boost::low_bits_mask_t< \
+ (v) >::sig_bits_fast == ((1ul << (v)) - 1) );
+#define PRIVATE_LOW_BITS_TEST(v)  do { PRIVATE_LOW_BITS_SLOW_TEST(v); \
+ PRIVATE_LOW_BITS_FAST_TEST(v); } while (false)
+
+
+int test_main( int, char*[] )
 {
+    using std::cout;
+    using std::endl;
 
-// List the ranges of template parameters tests (ranges are half-open)
-int const  max_offset = std::numeric_limits::digits;
+    cout << "Doing high_bit_mask_t tests." << endl;
+    PRIVATE_HIGH_BIT_TEST( 31 );
+    PRIVATE_HIGH_BIT_TEST( 30 );
+    PRIVATE_HIGH_BIT_TEST( 29 );
+    PRIVATE_HIGH_BIT_TEST( 28 );
+    PRIVATE_HIGH_BIT_TEST( 27 );
+    PRIVATE_HIGH_BIT_TEST( 26 );
+    PRIVATE_HIGH_BIT_TEST( 25 );
+    PRIVATE_HIGH_BIT_TEST( 24 );
+    PRIVATE_HIGH_BIT_TEST( 23 );
+    PRIVATE_HIGH_BIT_TEST( 22 );
+    PRIVATE_HIGH_BIT_TEST( 21 );
+    PRIVATE_HIGH_BIT_TEST( 20 );
+    PRIVATE_HIGH_BIT_TEST( 19 );
+    PRIVATE_HIGH_BIT_TEST( 18 );
+    PRIVATE_HIGH_BIT_TEST( 17 );
+    PRIVATE_HIGH_BIT_TEST( 16 );
+    PRIVATE_HIGH_BIT_TEST( 15 );
+    PRIVATE_HIGH_BIT_TEST( 14 );
+    PRIVATE_HIGH_BIT_TEST( 13 );
+    PRIVATE_HIGH_BIT_TEST( 12 );
+    PRIVATE_HIGH_BIT_TEST( 11 );
+    PRIVATE_HIGH_BIT_TEST( 10 );
+    PRIVATE_HIGH_BIT_TEST(  9 );
+    PRIVATE_HIGH_BIT_TEST(  8 );
+    PRIVATE_HIGH_BIT_TEST(  7 );
+    PRIVATE_HIGH_BIT_TEST(  6 );
+    PRIVATE_HIGH_BIT_TEST(  5 );
+    PRIVATE_HIGH_BIT_TEST(  4 );
+    PRIVATE_HIGH_BIT_TEST(  3 );
+    PRIVATE_HIGH_BIT_TEST(  2 );
+    PRIVATE_HIGH_BIT_TEST(  1 );
+    PRIVATE_HIGH_BIT_TEST(  0 );
 
-typedef boost::mpl::range_c             high_bit_offsets;
-typedef boost::mpl::range_c          low_bit_lengths;
-typedef boost::mpl::range_c  special_low_bit_lengths;
+    cout << "Doing low_bits_mask_t tests." << endl;
+    PRIVATE_LOW_BITS_TEST( 32 );  // Undefined behavior?  Whoops!
+    PRIVATE_LOW_BITS_TEST( 31 );
+    PRIVATE_LOW_BITS_TEST( 30 );
+    PRIVATE_LOW_BITS_TEST( 29 );
+    PRIVATE_LOW_BITS_TEST( 28 );
+    PRIVATE_LOW_BITS_TEST( 27 );
+    PRIVATE_LOW_BITS_TEST( 26 );
+    PRIVATE_LOW_BITS_TEST( 25 );
+    PRIVATE_LOW_BITS_TEST( 24 );
+    PRIVATE_LOW_BITS_TEST( 23 );
+    PRIVATE_LOW_BITS_TEST( 22 );
+    PRIVATE_LOW_BITS_TEST( 21 );
+    PRIVATE_LOW_BITS_TEST( 20 );
+    PRIVATE_LOW_BITS_TEST( 19 );
+    PRIVATE_LOW_BITS_TEST( 18 );
+    PRIVATE_LOW_BITS_TEST( 17 );
+    PRIVATE_LOW_BITS_TEST( 16 );
+    PRIVATE_LOW_BITS_TEST( 15 );
+    PRIVATE_LOW_BITS_TEST( 14 );
+    PRIVATE_LOW_BITS_TEST( 13 );
+    PRIVATE_LOW_BITS_TEST( 12 );
+    PRIVATE_LOW_BITS_TEST( 11 );
+    PRIVATE_LOW_BITS_TEST( 10 );
+    PRIVATE_LOW_BITS_TEST(  9 );
+    PRIVATE_LOW_BITS_TEST(  8 );
+    PRIVATE_LOW_BITS_TEST(  7 );
+    PRIVATE_LOW_BITS_TEST(  6 );
+    PRIVATE_LOW_BITS_TEST(  5 );
+    PRIVATE_LOW_BITS_TEST(  4 );
+    PRIVATE_LOW_BITS_TEST(  3 );
+    PRIVATE_LOW_BITS_TEST(  2 );
+    PRIVATE_LOW_BITS_TEST(  1 );
 
-// List a range with out-of-service values
-typedef boost::mpl::range_c  wild_bit_lengths;
-
-// Use SFINAE to check if a particular parameter is supported
-template < typename ValueT, template class Tmpl, ValueT Value >
-bool
-print_out_template( Tmpl const &, ValueT setting, char const
- *template_name, typename Tmpl::type *unused = 0 )
-{
-    // Too bad the type-id expression couldn't use the compact form "*unused",
-    // but type-ids of dereferenced null pointers throw by order of C++ 2003,
-    // sect. 5.2.8, para. 2 (although the result is not conceptually needed).
-    BOOST_TEST_MESSAGE( "There is an " << template_name << "<" << setting <<
-     "> specialization with type '" << typeid(typename
-     Tmpl::value_type).name() << "' and value '" << std::hex <<
-     Tmpl::value << "'." );
-    return true;
+    return boost::exit_success;
 }
-
-template < typename ValueT, typename T >
-bool
-print_out_template( T const &, ValueT setting, char const *template_name )
-{
-    BOOST_TEST_MESSAGE( "There is no " << template_name << "<" << setting <<
-     "> specialization." );
-    return false;
-}
-
-}  // unnamed namespace
-
-
-// Check the various integer-valued bit-masks
-BOOST_AUTO_TEST_SUITE( integer_mask_tests )
-
-// Check the bit-masks of one offset bit
-BOOST_AUTO_TEST_CASE_TEMPLATE( high_bit_mask_test, T, high_bit_offsets )
-{
-    typedef boost::mpl::integral_c::least, 1u>   one_type;
-    typedef boost::mpl::shift_left  result_type;
-
-    BOOST_MPL_ASSERT_RELATION( boost::high_bit_mask_t::high_bit, ==,
-     result_type::value );
-    BOOST_MPL_ASSERT_RELATION( boost::high_bit_mask_t::high_bit_fast,
-     ==, result_type::value );
-}
-
-// Check the bit-masks of a block of low-valued bits, non-zero block-lengths
-BOOST_AUTO_TEST_CASE_TEMPLATE( low_bits_mask_test, T, special_low_bit_lengths )
-{
-    // One can express (2^x - 1) in two ways
-    // 1. (1 << x) - 1
-    // 2. (1 << (x-1)) | ((1 << (x-1)) - 1)
-    // Since unsigneds have modulo arithmetic, [1] gives the right answer even
-    // when x is the number of bits in the register.  However, that last case
-    // gives warnings about the sole bit flowing past the register.  Applying
-    // distributive property backwards gives [2], which works without overflow.
-    typedef typename boost::mpl::prior::type                  shift_type;
-    typedef boost::mpl::integral_c::least, 1u>                  one_type;
-    typedef boost::mpl::shift_left      high_bit_type;
-    typedef typename boost::mpl::prior::type   low_bits_type;
-    typedef boost::mpl::bitor_    result_type;
-
-    BOOST_MPL_ASSERT_RELATION( boost::low_bits_mask_t::sig_bits, ==,
-     result_type::value );
-    BOOST_MPL_ASSERT_RELATION( boost::low_bits_mask_t::sig_bits_fast,
-     ==, result_type::value );
-}
-
-// Check the bit-masks of a block of low-valued bits, zero block-length
-BOOST_AUTO_TEST_CASE( special_low_bits_mask_test )
-{
-    // Just like "low_bits_mask_test" above, except that the shifts are negative
-    // when the bit-count is zero.  That causes a lot of warnings and errors, so
-    // special-case that bit-count.
-    BOOST_MPL_ASSERT_RELATION( boost::low_bits_mask_t<0u>::sig_bits, ==, 0 );
-    BOOST_MPL_ASSERT_RELATION(boost::low_bits_mask_t<0u>::sig_bits_fast, ==, 0);
-}
-
-// Check the specialization type status of given bit-offsets/lengths
-BOOST_AUTO_TEST_CASE_TEMPLATE( confirm_bounds_test, T, wild_bit_lengths )
-{
-    typedef boost::integer_hi_mask                    hi_type;
-    typedef boost::mpl::int_        hi_offset_type;
-    typedef boost::mpl::bool_  special_hi_type;
-
-    BOOST_MPL_ASSERT( (boost::mpl::equal_to< hi_offset_type, T >) );
-    BOOST_MPL_ASSERT( (boost::mpl::equal_to< special_hi_type,
-     boost::mpl::bool_<(T::value >= 0) && (T::value < max_offset)> >) );
-    BOOST_CHECK_EQUAL( print_out_template(hi_type(), hi_offset_type::value,
-     "integer_hi_mask"), special_hi_type::value );
-
-    typedef boost::integer_lo_mask                    lo_type;
-    typedef boost::mpl::int_         lo_length_type;
-    typedef boost::mpl::bool_  special_lo_type;
-
-    BOOST_MPL_ASSERT( (boost::mpl::equal_to< lo_length_type, T >) );
-    BOOST_MPL_ASSERT( (boost::mpl::equal_to< special_lo_type,
-     boost::mpl::bool_<(T::value >= 0) && (T::value <= max_offset)> >) );
-    BOOST_CHECK_EQUAL( print_out_template(lo_type(), lo_length_type::value,
-     "integer_lo_mask"), special_lo_type::value );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Verification of bugs and their fixes
-BOOST_AUTO_TEST_SUITE( bug_fix_tests )
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/integer_test.cpp b/test/integer_test.cpp
index 3749183..6bfff11 100644
--- a/test/integer_test.cpp
+++ b/test/integer_test.cpp
@@ -4,666 +4,288 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+
 //  See http://www.boost.org/libs/integer for documentation.
 
 //  Revision History
-//   16 Jul 08  Added MPL-compatible variants of the minimum-size and value-
-//              based integer templates. (Daryle Walker)
-//   15 Jul 08  Added exact-integer templates; added MPL-compatible variant of
-//              processor-optimized integer template. (Daryle Walker)
-//   14 Jul 08  Improved testing of processor-optimized integer template; added
-//              extended-integer support. (Daryle Walker)
-//   13 Jul 08  Modernized tests w/ MPL instead of giant macros (Daryle Walker)
-//   07 Jul 08  Changed tests to use the unit-test system (Daryle Walker)
 //   04 Oct 01  Added tests for new templates; rewrote code (Daryle Walker)
 //   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
 //   31 Aug 99  Initial version
 
-#define BOOST_TEST_MODULE  "Integer size-selection tests"
+#include   // for main, BOOST_CHECK
 
-#include   // unit testing framework
+#include    // for BOOST_NO_USING_TEMPLATE
+#include   // for boost::exit_success
+#include   // for boost::int_t, boost::uint_t
 
-#include           // for BOOST_NO_SFINAE
-#include          // for boost::uintmax_t, intmax_t
-#include          // for boost::int_t, boost::uint_t, etc.
-#include   // for boost::integer_traits
-#include           // for std::numeric_limits
-
-#include   // BOOST_HAS_XINT, BOOST_UXINT_MAX
-
-#include       // for boost::mpl::plus, divides
-#include           // for BOOST_MPL_ASSERT_RELATION, etc.
-#include             // for boost::mpl::back
-#include             // for boost::mpl::copy
-#include            // for boost::mpl::equal
-#include   // for boost::mpl::front_inserter
-#include              // for boost::mpl::int_
-#include       // for boost::mpl::integral_c
-#include       // for boost::mpl::joint_view
-#include         // for boost::mpl::pop_back
-#include        // for boost::mpl::push_back 
-#include       // for boost::mpl::push_front
-#include          // for boost::mpl::range_c
-#include      // for boost::mpl::shift_right
-#include             // for boost::mpl::sort
-#include        // for boost::mpl::transform
-#include   // for boost::mpl::transform_view
-#include      // for boost::mpl::unpack_args
-#include           // for boost::mpl::vector
-#include         // for boost::mpl::zip_view
-
-#include       // for boost::is_same
-#include   // for boost::make_signed
-
-#include   // for std::binary_search
-#include     // for ULONG_MAX, LONG_MAX, LONG_MIN, etc.
-#include     // for std::size_t
-#include    // for std::type_info
+#include    // for ULONG_MAX, LONG_MAX, LONG_MIN
+#include   // for std::cout (std::endl indirectly)
+#include   // for std::type_info
 
 
-// Control what the "fast" specialization of "short" is
-#ifndef CONTROL_FAST_SHORT
-#define CONTROL_FAST_SHORT  long
-#endif
-
-// Control if every potential bit-count is used, or only a selection
-// For me, full counts increase compile time from 90 seconds to 20 minutes!
-#ifndef CONTROL_FULL_COUNTS
-#define CONTROL_FULL_COUNTS  1
+// Control if the names of the types for each version
+// of the integer templates will be printed.
+#ifndef CONTROL_SHOW_TYPES
+#define CONTROL_SHOW_TYPES  0
 #endif
 
 
 // If specializations have not already been done, then we can confirm
-// the effects of the fast types by making a specialization.  If there
-// is a specialization for "short," make sure that CONTROL_FAST_SHORT
-// is set to a type distinct from "short" and the default implementation.
+// the effects of the "fast" types by making a specialization.
 namespace boost
 {
     template < >
-    struct fast_integral< short >
+    struct int_fast_t< short >
     {
-        typedef CONTROL_FAST_SHORT  type;
+        typedef long  fast;
     };
 }
 
 
-// Custom types/templates, helper functions, and objects
-namespace
-{
-
-// List the built-in integral types, excluding the ones that are strong-typedefs
-// of a lower type.
-typedef boost::mpl::vector<
-    unsigned char
-#if USHRT_MAX > UCHAR_MAX
-    , unsigned short
-#endif
-#if UINT_MAX > USHRT_MAX
-    , unsigned int
-#endif
-#if ULONG_MAX > UINT_MAX
-    , unsigned long
-#endif
-#if BOOST_HAS_XINT && (BOOST_UXINT_MAX > ULONG_MAX)
-    , boost::detail::uxint_t
-#endif
->  distinct_unsigned_types;
-
-typedef boost::mpl::transform<
-    distinct_unsigned_types,
-    boost::make_signed< boost::mpl::_1 >
->::type  distinct_signed_types;
-
-// List the digit counts for each integral type
-template < typename T >
-struct digits_of
-    : boost::mpl::int_< std::numeric_limits::digits >
-{
-};
-
-typedef boost::mpl::transform<
-    distinct_unsigned_types,
-    digits_of< boost::mpl::_1 >
->::type  distinct_integral_bit_counts;
-
-// Make list of bit counts between each offical point, plus CHAR_BIT/2
-typedef boost::mpl::transform_view<
-    boost::mpl::zip_view<
-        boost::mpl::vector<
-            boost::mpl::push_front<
-                boost::mpl::pop_back< distinct_integral_bit_counts >::type,
-                boost::mpl::integral_c< int, 0 >
-            >::type,
-            distinct_integral_bit_counts
-        >
-    >,
-    boost::mpl::unpack_args<
-        boost::mpl::divides<
-            boost::mpl::plus< boost::mpl::_1, boost::mpl::_2 >,
-            boost::mpl::integral_c< int, 2 >
-        >
-    >
->  median_bit_counts;
-
-// Maximum number of bits allowed
-typedef std::numeric_limits   intmax_limits;
-typedef std::numeric_limits  uintmax_limits;
-
-int const   intmax_bits =  intmax_limits::digits + 1;
-int const  uintmax_bits = uintmax_limits::digits;
-
-// Make master lists including an outlier beyond all valid bit counts
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c  bits_list;
+// Show the types of an integer template version
+#if CONTROL_SHOW_TYPES
+#define SHOW_TYPE(Template, Number, Type)  ::std::cout << "Type \"" \
+ #Template "<" #Number ">::" #Type "\" is \"" << typeid(Template <  \
+ Number > :: Type).name() << ".\"\n"
 #else
-typedef boost::mpl::sort<
-    boost::mpl::copy<
-        boost::mpl::joint_view<
-            distinct_integral_bit_counts,
-            median_bit_counts
-        >,
-        boost::mpl::front_inserter<
-            boost::mpl::vector<
-                boost::mpl::integral_c
-            >
-        >
-    >::type
->::type  bits_list;
+#define SHOW_TYPE(Template, Number, Type)
 #endif
 
-// Remove the outlier when all bits counts must be valid
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c  valid_bits_list;
+#define SHOW_TYPES(Template, Type)  SHOW_TYPE(Template, 32, Type); \
+ SHOW_TYPE(Template, 31, Type); SHOW_TYPE(Template, 30, Type); \
+ SHOW_TYPE(Template, 29, Type); SHOW_TYPE(Template, 28, Type); \
+ SHOW_TYPE(Template, 27, Type); SHOW_TYPE(Template, 26, Type); \
+ SHOW_TYPE(Template, 25, Type); SHOW_TYPE(Template, 24, Type); \
+ SHOW_TYPE(Template, 23, Type); SHOW_TYPE(Template, 22, Type); \
+ SHOW_TYPE(Template, 21, Type); SHOW_TYPE(Template, 20, Type); \
+ SHOW_TYPE(Template, 19, Type); SHOW_TYPE(Template, 18, Type); \
+ SHOW_TYPE(Template, 17, Type); SHOW_TYPE(Template, 16, Type); \
+ SHOW_TYPE(Template, 15, Type); SHOW_TYPE(Template, 14, Type); \
+ SHOW_TYPE(Template, 13, Type); SHOW_TYPE(Template, 12, Type); \
+ SHOW_TYPE(Template, 11, Type); SHOW_TYPE(Template, 10, Type); \
+ SHOW_TYPE(Template, 9, Type); SHOW_TYPE(Template, 8, Type); \
+ SHOW_TYPE(Template, 7, Type); SHOW_TYPE(Template, 6, Type); \
+ SHOW_TYPE(Template, 5, Type); SHOW_TYPE(Template, 4, Type); \
+ SHOW_TYPE(Template, 3, Type); SHOW_TYPE(Template, 2, Type); \
+ SHOW_TYPE(Template, 1, Type); SHOW_TYPE(Template, 0, Type)
+
+#define SHOW_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, (1UL << Number), Type)
+
+#define SHOW_SHIFTED_TYPES(Template, Type)  SHOW_SHIFTED_TYPE(Template, 30, Type); \
+ SHOW_SHIFTED_TYPE(Template, 29, Type); SHOW_SHIFTED_TYPE(Template, 28, Type); \
+ SHOW_SHIFTED_TYPE(Template, 27, Type); SHOW_SHIFTED_TYPE(Template, 26, Type); \
+ SHOW_SHIFTED_TYPE(Template, 25, Type); SHOW_SHIFTED_TYPE(Template, 24, Type); \
+ SHOW_SHIFTED_TYPE(Template, 23, Type); SHOW_SHIFTED_TYPE(Template, 22, Type); \
+ SHOW_SHIFTED_TYPE(Template, 21, Type); SHOW_SHIFTED_TYPE(Template, 20, Type); \
+ SHOW_SHIFTED_TYPE(Template, 19, Type); SHOW_SHIFTED_TYPE(Template, 18, Type); \
+ SHOW_SHIFTED_TYPE(Template, 17, Type); SHOW_SHIFTED_TYPE(Template, 16, Type); \
+ SHOW_SHIFTED_TYPE(Template, 15, Type); SHOW_SHIFTED_TYPE(Template, 14, Type); \
+ SHOW_SHIFTED_TYPE(Template, 13, Type); SHOW_SHIFTED_TYPE(Template, 12, Type); \
+ SHOW_SHIFTED_TYPE(Template, 11, Type); SHOW_SHIFTED_TYPE(Template, 10, Type); \
+ SHOW_SHIFTED_TYPE(Template, 9, Type); SHOW_SHIFTED_TYPE(Template, 8, Type); \
+ SHOW_SHIFTED_TYPE(Template, 7, Type); SHOW_SHIFTED_TYPE(Template, 6, Type); \
+ SHOW_SHIFTED_TYPE(Template, 5, Type); SHOW_SHIFTED_TYPE(Template, 4, Type); \
+ SHOW_SHIFTED_TYPE(Template, 3, Type); SHOW_SHIFTED_TYPE(Template, 2, Type); \
+ SHOW_SHIFTED_TYPE(Template, 1, Type); SHOW_SHIFTED_TYPE(Template, 0, Type)
+
+#define SHOW_POS_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, +(1L << Number), Type)
+
+#define SHOW_POS_SHIFTED_TYPES(Template, Type)  SHOW_POS_SHIFTED_TYPE(Template, 30, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 29, Type); SHOW_POS_SHIFTED_TYPE(Template, 28, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 27, Type); SHOW_POS_SHIFTED_TYPE(Template, 26, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 25, Type); SHOW_POS_SHIFTED_TYPE(Template, 24, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 23, Type); SHOW_POS_SHIFTED_TYPE(Template, 22, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 21, Type); SHOW_POS_SHIFTED_TYPE(Template, 20, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 19, Type); SHOW_POS_SHIFTED_TYPE(Template, 18, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 17, Type); SHOW_POS_SHIFTED_TYPE(Template, 16, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 15, Type); SHOW_POS_SHIFTED_TYPE(Template, 14, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 13, Type); SHOW_POS_SHIFTED_TYPE(Template, 12, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 11, Type); SHOW_POS_SHIFTED_TYPE(Template, 10, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 9, Type); SHOW_POS_SHIFTED_TYPE(Template, 8, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 7, Type); SHOW_POS_SHIFTED_TYPE(Template, 6, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 5, Type); SHOW_POS_SHIFTED_TYPE(Template, 4, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 3, Type); SHOW_POS_SHIFTED_TYPE(Template, 2, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 1, Type); SHOW_POS_SHIFTED_TYPE(Template, 0, Type)
+
+#define SHOW_NEG_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, -(1L << Number), Type)
+
+#define SHOW_NEG_SHIFTED_TYPES(Template, Type)  SHOW_NEG_SHIFTED_TYPE(Template, 30, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 29, Type); SHOW_NEG_SHIFTED_TYPE(Template, 28, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 27, Type); SHOW_NEG_SHIFTED_TYPE(Template, 26, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 25, Type); SHOW_NEG_SHIFTED_TYPE(Template, 24, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 23, Type); SHOW_NEG_SHIFTED_TYPE(Template, 22, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 21, Type); SHOW_NEG_SHIFTED_TYPE(Template, 20, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 19, Type); SHOW_NEG_SHIFTED_TYPE(Template, 18, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 17, Type); SHOW_NEG_SHIFTED_TYPE(Template, 16, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 15, Type); SHOW_NEG_SHIFTED_TYPE(Template, 14, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 13, Type); SHOW_NEG_SHIFTED_TYPE(Template, 12, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 11, Type); SHOW_NEG_SHIFTED_TYPE(Template, 10, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 9, Type); SHOW_NEG_SHIFTED_TYPE(Template, 8, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 7, Type); SHOW_NEG_SHIFTED_TYPE(Template, 6, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 5, Type); SHOW_NEG_SHIFTED_TYPE(Template, 4, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 3, Type); SHOW_NEG_SHIFTED_TYPE(Template, 2, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 1, Type); SHOW_NEG_SHIFTED_TYPE(Template, 0, Type)
+
+
+// Test if a constant can fit within a certain type
+#define PRIVATE_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < Number > :: Type ( Value ) == Value )
+
+#if ULONG_MAX > 0xFFFFFFFFL
+#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_FIT_TEST(Template, 64, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 63, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 62, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 61, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 60, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 59, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 58, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 57, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 56, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 55, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 54, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 53, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 52, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 51, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 50, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 49, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 48, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 47, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 46, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 45, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 44, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 43, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 42, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 41, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 40, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 39, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 38, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 37, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 36, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 35, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 34, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 33, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
 #else
-typedef boost::mpl::pop_back::type  valid_bits_list;
+#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
 #endif
 
-// Replace the minimum bit count with one more, so right-shifting by a stored
-// value doesn't give an invalid result
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c
-  valid_to_decrease_bits_list;
+#define PRIVATE_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (ULONG_MAX >> Number) > :: Type ( Value ) == Value )
+
+#define PRIVATE_SHIFTED_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
+
+#define PRIVATE_POS_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (LONG_MAX >> Number) > :: Type ( Value ) == Value )
+
+#define PRIVATE_POS_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
+
+#define PRIVATE_NEG_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (LONG_MIN >> Number) > :: Type ( Value ) == Value )
+
+#define PRIVATE_NEG_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
+
+
+// Test program
+int
+test_main
+(
+    int,
+    char*[]
+)
+{
+#ifndef BOOST_NO_USING_TEMPLATE
+    using boost::int_t;
+    using boost::uint_t;
+    using boost::int_max_value_t;
+    using boost::int_min_value_t;
+    using boost::uint_value_t;
 #else
-typedef valid_bits_list  valid_to_decrease_bits_list;
+    using namespace boost;
 #endif
 
-// Replace the maximum bit count with one less, so left-shifting by a stored
-// value doesn't give an invalid result
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c  valid_to_increase_ubits_list;
-#else
-typedef boost::mpl::push_back<
-    boost::mpl::pop_back< valid_bits_list >::type,
-    boost::mpl::integral_c< int, uintmax_bits - 1 >
->::type  valid_to_increase_ubits_list;
-#endif
-
-// Do it again for signed types since they have one-less bit to use for the
-// mantissa (don't want to shift into the sign bit)
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c
-  valid_to_increase_sbits_list;
-#else
-typedef boost::mpl::push_back<
-    boost::mpl::pop_back< valid_bits_list >::type,
-    boost::mpl::integral_c< int, intmax_bits - 3 >
->::type  valid_to_increase_sbits_list;
-#endif
-
-// List the digit counts for each integral type, this time as an object, an
-// array working as a sorted list
-int const  integral_bit_lengths[] = {
-    std::numeric_limits< unsigned char >::digits
-#if USHRT_MAX > UCHAR_MAX
-    , std::numeric_limits< unsigned short >::digits
-#endif
-#if UINT_MAX > USHRT_MAX
-    , std::numeric_limits< unsigned int >::digits
-#endif
-#if ULONG_MAX > UINT_MAX
-    , std::numeric_limits< unsigned long >::digits
-#endif
-#if BOOST_HAS_XINT && (BOOST_UXINT_MAX > ULONG_MAX)
-    , std::numeric_limits< boost::detail::uxint_t >::digits
-#endif
-};
-
-std::size_t const  integral_type_count = sizeof(integral_bit_lengths) /
- sizeof(integral_bit_lengths[0]);
-
-// "Template-typedefs" to reduce two-argument templates to single-argument.
-// This way, all the MPL-compatible templates have the same form, for below.
-template < int Bits >
-struct signed_sized_integral  : boost::sized_integral  {};
-
-template < int Bits >
-struct unsigned_sized_integral  : boost::sized_integral  {};
-
-template < int Bits >
-struct signed_exact_integral  : boost::exact_integral  {};
-
-template < int Bits >
-struct unsigned_exact_integral  : boost::exact_integral  {};
-
-// Use SFINAE to check if a particular parameter is supported
-#ifndef BOOST_NO_SFINAE
-template < typename ValueT, template class Tmpl, ValueT Value >
-bool
-print_out_template( Tmpl const &, ValueT setting, char const
- *template_pre_name, char const *template_post_name, typename Tmpl::type
- *unused = 0 )
-{
-    // Too bad the type-id expression couldn't use the compact form "*unused",
-    // but type-ids of dereferenced null pointers throw by order of C++ 2003,
-    // sect. 5.2.8, para. 2 (although the result is not conceptually needed).
-    BOOST_TEST_MESSAGE( "This is " << template_pre_name << setting
-     << template_post_name << " specialization, with type '" << typeid(typename
-     Tmpl::type).name() << "'." );
-    return true;
+    SHOW_TYPES( int_t, least );
+    SHOW_TYPES( int_t, fast );
+    SHOW_TYPES( uint_t, least );
+    SHOW_TYPES( uint_t, fast );
+    SHOW_POS_SHIFTED_TYPES( int_max_value_t, least );
+    SHOW_POS_SHIFTED_TYPES( int_max_value_t, fast );
+    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, least );
+    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, fast );
+    SHOW_SHIFTED_TYPES( uint_value_t, least );
+    SHOW_SHIFTED_TYPES( uint_value_t, fast );
+     
+    PRIVATE_FIT_TESTS( int_t, least, long, LONG_MAX );
+    PRIVATE_FIT_TESTS( int_t, fast, long, LONG_MAX );
+    PRIVATE_FIT_TESTS( uint_t, least, unsigned long, ULONG_MAX );
+    PRIVATE_FIT_TESTS( uint_t, fast, unsigned long, ULONG_MAX );
+    PRIVATE_POS_FIT_TESTS( int_max_value_t, least, long, LONG_MAX );
+    PRIVATE_POS_FIT_TESTS( int_max_value_t, fast, long, LONG_MAX );
+    PRIVATE_NEG_FIT_TESTS( int_min_value_t, least, long, LONG_MIN );
+    PRIVATE_NEG_FIT_TESTS( int_min_value_t, fast, long, LONG_MIN );
+    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, least, unsigned long, ULONG_MAX );
+    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, fast, unsigned long, ULONG_MAX );
+        
+    return boost::exit_success;
 }
-
-template < typename ValueT, typename T >
-bool
-print_out_template( T const &, ValueT setting, char const *template_pre_name,
- char const *template_post_name )
-{
-    BOOST_TEST_MESSAGE( "Looking for " << template_pre_name << setting
-     << template_post_name << " specialization?  It doesn't exist." );
-    return false;
-}
-#else
-#error "These tests cannot work without Substitution-Failure-Is-Not-An-Error"
-#endif
-
-// Get the extreme values for each integral type
-template < typename T >
-struct minimum_of
-    : boost::mpl::integral_c< T, boost::integer_traits::const_min >
-{
-};
-
-template < typename T >
-struct maximum_of
-    : boost::mpl::integral_c< T, boost::integer_traits::const_max >
-{
-};
-
-}  // unnamed namespace
-
-
-// Check the processor-optimzed type system
-BOOST_AUTO_TEST_SUITE( optimized_type_tests )
-
-// Check the optimzed type override of a given type
-BOOST_AUTO_TEST_CASE( fast_type_test )
-{
-    typedef short                               least_type;
-    typedef boost::int_fast_t::fast  fast_type;
-    typedef std::numeric_limits     least_limits;
-    typedef std::numeric_limits       fast_limits;
-
-    typedef boost::fast_integral::type  real_fast_type;
-
-    BOOST_MPL_ASSERT_RELATION( (boost::is_same::value),
-     ==, false );
-    BOOST_MPL_ASSERT_RELATION( (boost::is_same::value), ==, true );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::is_specialized, ==, true );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::is_signed &&
-     fast_limits::is_bounded, ==, true );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::radix, ==, 2 );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::digits, >=, least_limits::digits );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Check if given types can support given size parameters
-BOOST_AUTO_TEST_SUITE( show_type_tests )
-
-// Check the specialization type status of given bit lengths, minimum
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_lengths_test, T, bits_list )
-{
-    BOOST_CHECK_EQUAL( print_out_template(signed_sized_integral(),
-     T::value, "a sized_integral<", ", signed>"), T::value && (T::value <=
-     intmax_bits) );
-    BOOST_CHECK_EQUAL( print_out_template(unsigned_sized_integral(),
-     T::value, "a sized_integral<", ", unsigned>"), T::value <= uintmax_bits );
-}
-
-// Check the classic specialization type status of given bit lengths, minimum,
-// unsigned
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_classic_lengths_unsigned_test, T,
- valid_bits_list )
-{
-    // This test is supposed to replace the following printouts given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for N := 32 downto 0
-    //      cout << "Type '" << Template << "<" N << ">::" << Type << "' is '"
-    //      << typeid(Template::Type).name << ".'\n"
-    //  end for
-    // end Routine
-    // with Template = {int_t, uint_t}; Type = {least, fast}
-    // But now we'll use template meta-programming instead of macros.  The limit
-    // of type-lists is usually less than 32 (not to mention 64) elements, so we
-    // have to take selected values.  The only interesting part is if the bit
-    // count is too large, and we can't check that yet.
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits::least>::digits, >=, T::value );
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits::fast>::digits, >=, T::value );
-}
-
-// Check the classic specialization type status of given bit lengths, minimum,
-// signed
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_classic_lengths_signed_test, T,
- valid_to_decrease_bits_list )
-{
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits::least>::digits, >=, T::value - 1 );
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits::fast>::digits, >=, T::value - 1 );
-}
-
-// Check size comparisons of given value support, unsigned
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_shifted_unsigned_values_test, T,
- valid_to_increase_ubits_list )
-{
-    // This test is supposed to replace the following printouts given in
-    // puesdo-code by:
-    // Routine: Type
-    //  for N := 30 downto 0
-    //      cout << "Type '" << uint_value_t << "<" (1ul << N) << ">::" << Type
-    //       << "' is '"<< typeid(uint_value_t<(1ul << N)>::Type).name << ".'\n"
-    //  end for
-    // end Routine
-    // with Type = {least, fast}
-    // But now we'll use template meta-programming instead of macros.  The limit
-    // of type-lists is usually less than 32 (not to mention 64) elements, so we
-    // have to take selected values.  The interesting parts are where N is the
-    // length of a integral type, so 1 << N would have to fit in the next larger
-    // type.  (This is why N can't be more than bitlength(uintmax_t) - 1.)
-    boost::uintmax_t const  one = 1u;
-
-    BOOST_MPL_ASSERT( (boost::mpl::equal< boost::maximum_unsigned_integral<(one
-     << T::value)>, unsigned_sized_integral >) );
-}
-
-// Check size comparisons of given value support, signed
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_shifted_signed_values_test, T,
- valid_to_increase_sbits_list )
-{
-    // This test is supposed to replace the following printouts given in
-    // puesdo-code by:
-    // Routine: Type
-    //  for N := 30 downto 0
-    //      cout << "Type '" << int_max_value_t << "<" +(1ul << N) << ">::" <<
-    //       Type << "' is '" << typeid(int_max_value_t<+(1ul << N)>::Type).name
-    //       << ".'\n"
-    //      cout << "Type '" << int_min_value_t << "<" -(1ul << N) << ">::" <<
-    //       Type << "' is '" << typeid(int_min_value_t<-(1ul << N)>::Type).name
-    //       << ".'\n"
-    //  end for
-    // end Routine
-    // with Type = {least, fast}
-    // But now we'll use template meta-programming instead of macros.  The limit
-    // of type-lists is usually less than 32 (not to mention 64) elements, so we
-    // have to take selected values.  The interesting parts are where N is the
-    // length of a integral type, so 1 << N would have to fit in the next larger
-    // type.  (This is why N can't be more than bitlength(intmax_t) - 1.  Note
-    // that bitlength(intmax_t) + 1 == bitlength(uintmax_t).)
-    static  boost::intmax_t const  one = 1;
-
-    BOOST_MPL_ASSERT( (boost::mpl::equal< boost::maximum_signed_integral<+(one
-     << T::value)>, signed_sized_integral >) );
-    BOOST_MPL_ASSERT( (boost::mpl::equal< boost::minimum_signed_integral<-(one
-     << T::value)>, signed_sized_integral >) );
-}
-
-// Check the specialization type status of given bit lengths, exact only
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_exact_lengths_test, T, bits_list )
-{
-    bool const  is_exact_length = std::binary_search( integral_bit_lengths,
-     integral_bit_lengths + integral_type_count, T::value );
-
-    BOOST_CHECK_EQUAL( print_out_template(signed_exact_integral(),
-     T::value, "an exact_integral<", ", signed>"), is_exact_length );
-    BOOST_CHECK_EQUAL( print_out_template(unsigned_exact_integral(),
-     T::value, "an exact_integral<", ", unsigned>"), is_exact_length );
-}
-
-// Check the classic specialization type status of given bit lengths, exact only
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_classic_exact_lengths_test, T,
- distinct_integral_bit_counts )
-{
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits::exact>::digits, ==, T::value - 1 );
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits::exact>::digits, ==, T::value );
-}
-
-// Check if MPL-compatible templates give bad returns for out-of-range values
-BOOST_AUTO_TEST_CASE( show_not_type_for_parameter_test )
-{
-    typedef signed_sized_integral< 3>   ssz3_type;
-    typedef signed_sized_integral< 0>   ssz0_type;
-    typedef signed_sized_integral<-3>  ssz3n_type;
-
-    BOOST_CHECK(  print_out_template(ssz3_type(), ssz3_type::bit_count,
-     "a sized_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(ssz0_type(), ssz0_type::bit_count,
-     "a sized_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(ssz3n_type(), ssz3n_type::bit_count,
-     "a sized_integral<", ", signed>") );
-
-    typedef unsigned_sized_integral< 3>   usz3_type;
-    typedef unsigned_sized_integral< 0>   usz0_type;
-    typedef unsigned_sized_integral<-3>  usz3n_type;
-
-    BOOST_CHECK(  print_out_template(usz3_type(), usz3_type::bit_count,
-     "a sized_integral<", ", unsigned>") );
-    BOOST_CHECK(  print_out_template(usz0_type(), usz0_type::bit_count,
-     "a sized_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(usz3n_type(), usz3n_type::bit_count,
-     "a sized_integral<", ", unsigned>") );
-
-    typedef signed_exact_integral< CHAR_BIT >     se8_type;
-    typedef signed_exact_integral< 3>             se3_type;
-    typedef signed_exact_integral< 0>             se0_type;
-    typedef signed_exact_integral<-3>            se3n_type;
-    typedef signed_exact_integral< - CHAR_BIT >  se8n_type;
-
-    BOOST_CHECK(  print_out_template(se8_type(), se8_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se3_type(), se3_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se0_type(), se0_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se3n_type(), se3n_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se8n_type(), se8n_type::bit_count,
-     "an exact_integral<", ", signed>") );
-
-    typedef unsigned_exact_integral< CHAR_BIT >     ue8_type;
-    typedef unsigned_exact_integral< 3>             ue3_type;
-    typedef unsigned_exact_integral< 0>             ue0_type;
-    typedef unsigned_exact_integral<-3>            ue3n_type;
-    typedef unsigned_exact_integral< - CHAR_BIT >  ue8n_type;
-
-    BOOST_CHECK(  print_out_template(ue8_type(), ue8_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue3_type(), ue3_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue0_type(), ue0_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue3n_type(), ue3n_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue8n_type(), ue8n_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-
-    typedef boost::maximum_signed_integral< 15>   max15_type;
-    typedef boost::maximum_signed_integral<  0>    max0_type;
-    typedef boost::maximum_signed_integral<-15>  max15n_type;
-
-    BOOST_CHECK(  print_out_template(max15_type(), max15_type::bound,
-     "a maximum_signed_integral<", ">") );
-    BOOST_CHECK( !print_out_template(max0_type(), max0_type::bound,
-     "a maximum_signed_integral<", ">") );
-    BOOST_CHECK( !print_out_template(max15n_type(), max15n_type::bound,
-     "a maximum_signed_integral<", ">") );
-
-    typedef boost::minimum_signed_integral< 15>   min15_type;
-    typedef boost::minimum_signed_integral<  0>    min0_type;
-    typedef boost::minimum_signed_integral<-15>  min15n_type;
-
-    BOOST_CHECK( !print_out_template(min15_type(), min15_type::bound,
-     "a minimum_signed_integral<", ">") );
-    BOOST_CHECK( !print_out_template(min0_type(), min0_type::bound,
-     "a minimum_signed_integral<", ">") );
-    BOOST_CHECK(  print_out_template(min15n_type(), min15n_type::bound,
-     "a minimum_signed_integral<", ">") );
-
-    typedef boost::maximum_unsigned_integral<15>   umax15_type;
-    typedef boost::maximum_unsigned_integral< 0>    umax0_type;
-
-    BOOST_CHECK( print_out_template(umax15_type(), umax15_type::bound,
-     "a maximum_unsigned_integral<", ">") );
-    BOOST_CHECK( print_out_template(umax0_type(), umax0_type::bound,
-     "a maximum_unsigned_integral<", ">") );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Check if given constants can fit in given types
-BOOST_AUTO_TEST_SUITE( fit_type_tests )
-
-// Check if large value can fit its minimum required size, by size
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_masked_values_test, T,
- valid_to_decrease_bits_list )
-{
-    // This test is supposed to replace the following checks given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for ( N = 32, V = Template:Max ; N >= 0 ; --N, V >>= 1 )
-    //      Confirm( static_cast::Type>(V) == V );
-    //  end for
-    // end Routine
-    // with Template = {int_t, uint_t}; Type = {least, fast};
-    //      Template:Max = { intmax_t.Max for int_t, uintmax_t.Max for uint_t }
-    // In other words, the selected type doesn't mask out any bits it's not
-    // supposed to.  But now we'll use template meta-programming instead of
-    // macros.  The limit of type-lists is usually less than 32 (not to mention
-    // 64) elements, so we have to take selected values.
-    static  int const       count = T::value;
-    int const               shift = uintmax_bits - count;
-    boost::uintmax_t const  value_u = uintmax_limits::max
-     BOOST_PREVENT_MACRO_SUBSTITUTION () >> shift;
-    boost::intmax_t const   value_s = intmax_limits::max
-     BOOST_PREVENT_MACRO_SUBSTITUTION () >> shift;
-
-    BOOST_CHECK_EQUAL( static_cast::type>(value_u), value_u );
-    BOOST_CHECK_EQUAL( static_cast::least>(value_u), value_u );
-    BOOST_CHECK_EQUAL( static_cast::fast>(value_u), value_u );
-
-    BOOST_CHECK_EQUAL( static_cast::type>(value_s), value_s );
-    BOOST_CHECK_EQUAL( static_cast::least>(value_s), value_s );
-    BOOST_CHECK_EQUAL( static_cast::fast>(value_s), value_s );
-}
-
-// Check if a large value can only fit of its exact bit length
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_exact_lengths_test, T,
- distinct_integral_bit_counts )
-{
-    typename boost::exact_integral::type const  one_u( 1u ),
-     high_bit_u( one_u << (T::value - 1) ), repeated_bits_u( (high_bit_u << 1) |
-     high_bit_u );
-
-    BOOST_CHECK( high_bit_u );
-    BOOST_CHECK_EQUAL( repeated_bits_u, high_bit_u );
-
-    typename boost::exact_integral::type const  one_s( 1 ),
-     high_bit_s( one_s << (T::value - 2) ), repeated_bits_s( (high_bit_s << 1) |
-     high_bit_s ), repeated_2bits_s( (repeated_bits_s << 1) | high_bit_s );
-
-    BOOST_CHECK( high_bit_s > 0 );
-    BOOST_CHECK( repeated_bits_s < 0 );
-    BOOST_CHECK_EQUAL( repeated_bits_s, repeated_2bits_s );
-}
-
-// Check if large value can fit its minimum required size, by value, unsigned
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_shifted_unsigned_values_test, T,
- valid_to_increase_ubits_list )
-{
-    // This test is supposed to replace the following checks given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for ( N = 0, V = Template:Extreme ; N < 32 ; ++N, V >>= 1 )
-    //      Confirm( static_cast::Type>(V) == V );
-    //  end for
-    // end Routine
-    // with Template = {uint_value_t}; Type = {least, fast}; Template:Extreme =
-    //      {uintmax_t.Max for uint_value_t}
-    // In other words, the selected type doesn't mask out any bits it's not
-    // supposed to.  But now we'll use template meta-programming instead of
-    // macros.  The limit of type-lists is usually less than 32 (not to mention
-    // 64) elements, so we have to take selected values.
-    using boost::uintmax_t;
-
-    typedef boost::mpl::shift_right, T>  maxi_type;
-
-    uintmax_t const  maxi = maxi_type::value;
-
-    BOOST_CHECK_EQUAL( static_cast::least>(maxi), maxi );
-    BOOST_CHECK_EQUAL( static_cast::fast>(maxi), maxi );
-}
-
-// Check if large value can fit its minimum required size, by value, signed
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_shifted_signed_values_test, T,
- valid_to_increase_sbits_list )
-{
-    // This test is supposed to replace the following checks given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for ( N = 0, V = Template:Extreme ; N < 32 ; ++N, V >>= 1 )
-    //      Confirm( static_cast::Type>(V) == V );
-    //  end for
-    // end Routine
-    // with Template = {int_max_value_t, int_min_value_t}; Type = {least, fast};
-    //      Template:Extreme = {intmax_t.Min for int_min_value_t, intmax_t.Max
-    //      for int_max_value_t}
-    // In other words, the selected type doesn't mask out any bits it's not
-    // supposed to.  But now we'll use template meta-programming instead of
-    // macros.  The limit of type-lists is usually less than 32 (not to mention
-    // 64) elements, so we have to take selected values.
-    using boost::intmax_t;
-
-    typedef boost::mpl::shift_right, T>  mini_type;
-    typedef boost::mpl::shift_right, T>  maxi_type;
-
-    intmax_t const  maxi = maxi_type::value, mini = mini_type::value;
-
-    BOOST_CHECK_EQUAL( static_cast::least>(maxi), maxi );
-    BOOST_CHECK_EQUAL( static_cast::fast>(maxi), maxi );
-
-    BOOST_CHECK_EQUAL( static_cast::least>(mini), mini );
-    BOOST_CHECK_EQUAL( static_cast::fast>(mini), mini );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Verification of bugs and their fixes
-BOOST_AUTO_TEST_SUITE( bug_fix_tests )
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/issue_2134.cpp b/test/issue_2134.cpp
deleted file mode 100644
index 26f8962..0000000
--- a/test/issue_2134.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//  boost Issue #2134 test program  ------------------------------------------//
-
-//  Copyright Daryle Walker 2008.  Distributed under the Boost
-//  Software License, Version 1.0. (See the accompanying file
-//  LICENSE_1_0.txt or a copy at .)
-
-//  See  for documentation.
-//  See  for the issue involved.
-
-//  Revision History
-//   23 Jul 2008  Initial version
-
-// Control if the inclusion error is triggered
-#ifndef CONTROL_INCLUDE_TRAITS
-#define CONTROL_INCLUDE_TRAITS  1
-#endif
-
-#if CONTROL_INCLUDE_TRAITS
-// This file defines boost::detail::integer_traits.
-#include 
-#endif
-
-// This is the file with the issue.  It has items within the boost::detail
-// namespace that referenced an unadorned "integer_traits".  This was meant to
-// refer to boost::integer_traits.  However, 
-// defines a boost::detail::integer_traits.  If that header is #included before
-// this one, then b.d.integer_traits (rightfully) took priority, which lead to a
-// syntax error.
-#include 
-
-
-// Main program, minimal (since this is a compile test)
-int  main()  { return 0; }