This commit was manufactured by cvs2svn to create branch

'python-v2-dev'. [SVN r14785]
2025-06-26 12:31:40 +02:00 · 2002-08-12 13:35:54 +00:00
27 changed files with 895 additions and 2630 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,25 +0,0 @@
 #----------------------------------------------------------------------------
 # This file was automatically generated from the original CMakeLists.txt file
 # Add a variable to hold the headers for the library
 set (lib_headers
    integer.hpp
    integer_fwd.hpp
    integer_traits.hpp
    integer
 )
 # Add a library target to the build system
 boost_library_project(
  integer
  #  SRCDIRS 
  TESTDIRS  test
  HEADERS ${lib_headers}
  #  DOCDIRS 
  DESCRIPTION  "The organization of boost integer headers and classes is designed to take advantage of <stdint.h> types from the 1999 C standard without resorting to undefined behavior in terms of the 1998 C++ standard. The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace boost without placing any names in namespace std."
  MODULARIZED 
  AUTHORS  "Beman Dawes <bdawes -at- acm.org>"
           "Daryle Walker <darylew -at- hotmail.com>"
  #  MAINTAINERS 
 )
--- a/cstdint.htm
+++ b/cstdint.htm
@ -2,14 +2,14 @@
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Header boost/cstdint.hpp</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
-<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" width="277" height="86">Header
+<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Header
 boost/cstdint.hpp&nbsp;</h1>
 <p>The header <code><a href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;</a></code>
 provides the typedef's useful for
@ -18,7 +18,7 @@ writing portable code that requires certain integer widths.  All typedef's are i
 header &lt;stdint.h&gt;.&nbsp; 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 <code>long long</code> is not [yet] included in the C++ standard.</p>
-<p>See <a href="test/cstdint_test.cpp">cstdint_test.cpp</a> for a test program.</p>
+<p>See <a href="cstdint_test.cpp">cstdint_test.cpp</a> for a test program.</p>
 <h2>Exact-width integer types</h2>
 <p>The typedef <code>int#_t</code>, with # replaced by the width, designates a
 signed integer type of exactly # bits; <code>int8_t</code> denotes an 8-bit
@ -69,13 +69,10 @@ representing any value of any signed integer type.</p>
 capable of representing any value of any unsigned integer type.</p>
 <p>These types are required.</p>
 <hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->06 Nov 2007<!--webbot bot="Timestamp" endspan i-checksum="15272" -->
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" -->
 </p>
-<p><EFBFBD> Copyright Beman Dawes 2000</p>
+<p>&nbsp;</p>
 <p>Distributed under the Boost Software License, Version 1.0. See
 <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
 </body>
-</html>
+</html>
--- a/test/cstdint_test.cpp
+++ b/test/cstdint_test.cpp
@ -1,29 +1,26 @@
 //  boost cstdint.hpp test program  ------------------------------------------//
-//  Copyright Beman Dawes 2000.  Distributed under the Boost
+//  (C) Copyright Beman Dawes 2000. Permission to copy, use, modify, sell
-//  Software License, Version 1.0. (See accompanying file
+//  and distribute this software is granted provided this copyright
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  notice appears in all copies. This software is provided "as is" without
 //  express or implied warranty, and with no claim as to its suitability for
 //  any purpose.
-
+//  See http://www.boost.org for most recent version including documentation.
 //  See http://www.boost.org/libs/integer for documentation.
 //  Revision History
 //   11 Sep 01  Adapted to work with macros defined in native stdint.h (John Maddock)
 //   12 Nov 00  Adapted to merged <boost/cstdint.hpp>
 //   23 Sep 00  Added INTXX_C constant macro support + int64_t support (John Maddock).
 //   28 Jun 00  Initial version
 #define __STDC_CONSTANT_MACROS
 #include <cassert>
 #include <iostream>
 #define __STDC_CONSTANT_MACROS
 #include <boost/cstdint.hpp>
 #ifdef NDEBUG
-int main()
+#error This test makes no sense with NDEBUG defined
-{
+#endif
  std::cout << "This test makes no sense with NDEBUG defined.\n";
  return 0;
 }
 #else
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 //
@ -113,24 +110,10 @@ void integral_constant_type_check(T1, T2)
   assert(sizeof(T1) == sizeof(T2));
   assert(t1 == t2);
 #endif
 #if defined(BOOST_HAS_STDINT_H)
   // native headers are permitted to promote small
   // unsigned types to type int:
   if(sizeof(T1) >= sizeof(int))
   {
      if(t1 > 0)
        assert(t2 > 0);
      else
        assert(!(t2 > 0));
   }
   else if(t1 < 0)
      assert(!(t2 > 0));
 #else
   if(t1 > 0)
     assert(t2 > 0);
   else
     assert(!(t2 > 0));
 #endif
 }
@ -230,4 +213,5 @@ int main()
  std::cout << "OK\n";
  return 0;
 }
-#endif
+
--- a/doc/integer_mask.html
+++ b/doc/integer_mask.html
@ -5,14 +5,10 @@
 </head>
 <body bgcolor="white" text="black" link="blue" vlink="purple" alink="red">
-<h1><img src="../../../boost.png" alt="boost.png (6897 bytes)"
+<h1><img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
 align="middle" width="277" height="86">Integer Bit Mask Templates</h1>
-<p>The class templates in <cite><a
+<p>The class templates in <cite><a href="../../../boost/integer/integer_mask.hpp">&lt;boost/integer/integer_mask.hpp&gt;</a></cite> 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 <a href="../integer.htm">integer type selection templates</a> header.</p>
 href="../../../boost/integer/integer_mask.hpp">&lt;boost/integer/integer_mask.hpp&gt;</a></cite>
 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 <a
 href="../integer.htm">integer type selection templates</a> header.</p>
 <h2><a name="contents">Contents</a></h2>
@ -21,7 +17,6 @@ href="../integer.htm">integer type selection templates</a> header.</p>
 	<li><a href="#synopsis">Synopsis</a></li>
 	<li><a href="#single">Single Bit-Mask Class Template</a></li>
 	<li><a href="#group">Group Bit-Mask Class Template</a></li>
 	<li><a href="#mpl">MPL-Compatible Variants</a></li>
 	<li><a href="#example">Example</a></li>
 	<li><a href="#demo">Demonstration Program</a></li>
 	<li><a href="#rationale">Rationale</a></li>
@ -31,68 +26,39 @@ href="../integer.htm">integer type selection templates</a> header.</p>
 <h2><a name="synopsis">Synopsis</a></h2>
 <blockquote><pre>
-#include &lt;<a href="../../../boost/integer_fwd.hpp">boost/integer_fwd.hpp</a>&gt;  <i>// forwarding header</i>
+#include &lt;cstddef&gt;  <i>// for std::size_t</i>
 #include &lt;<a href="../../../boost/integer.hpp">boost/integer.hpp</a>&gt;      <i>// for boost::int_fast_t</i>
 #include &lt;cstddef&gt;                <i>// for std::size_t</i>
 namespace boost
 {
 // MPL-compatible
 template &lt; int Offset &gt;
 struct integer_hi_mask
 {
    static  bool const  is_specialized = <em>implementation_supplied</em>;
    static  int const   bit_offset = Offset;
    typedef <em>implementation_supplied</em>  type;
    typedef <em>implementation_supplied</em>  value_type;
    static  value_type const  value = <em>implementation_supplied</em>;
    // There are other (optional) operations....
 };
 template &lt; int Length &gt;
 struct integer_lo_mask
 {
    static  bool const  is_specialized = <em>implementation_supplied</em>;
    static  int const   bit_count = Length;
    typedef <em>implementation_supplied</em>  type;
    typedef <em>implementation_supplied</em>  value_type;
    static  value_type const  value = <em>implementation_supplied</em>;
    // There are other (optional) operations....
 };
 // single
 template &lt; std::size_t Bit &gt;
-class high_bit_mask_t
+struct high_bit_mask_t
 {
-public:
+    typedef <em>implementation_supplied</em>  least;
-    typedef typename integer_hi_mask&lt;Bit&gt;::value_type  least;
+    typedef <em>implementation_supplied</em>   fast;
    typedef int_fast_t&lt;least&gt;::fast                     fast;
-    static const least  high_bit = integer_hi_mask&lt;Bit&gt;::value;
+    static const least  high_bit = <em>implementation_defined</em>;
-    static const fast   high_bit_fast = high_bit;
+    static const fast   high_bit_fast = <em>implementation_defined</em>;
    static const std::size_t  bit_position = Bit;
 };
 // group
 template &lt; std::size_t Bits &gt;
-class low_bits_mask_t
+struct low_bits_mask_t
 {
-public:
+    typedef <em>implementation_supplied</em>  least;
-    typedef typename integer_lo_mask&lt;Bits&gt;::value_type  least;
+    typedef <em>implementation_supplied</em>   fast;
    typedef int_fast_t&lt;least&gt;::fast                      fast;
-    static const least  sig_bits = integer_lo_mask&lt;Bits&gt;::value;
+    static const least  sig_bits = <em>implementation_defined</em>;
-    static const fast   sig_bits_fast = sig_bits;
+    static const fast   sig_bits_fast = <em>implementation_defined</em>;
    static const std::size_t  bit_count = Bits;
 };
 // Specializations for low_bits_mask_t exist for certain bit counts.
 }  // namespace boost
 </pre></blockquote>
@ -183,149 +149,16 @@ describes the members of an instantiation of
 	</tr>
 </table>
-<h2><a name="mpl">MPL-Compatible Variants</a></h2>
+<p><strong>Implementation Note</strong><br>
-
+When <code>Bits</code> is the exact size of a built-in unsigned type,
-<p>The single and group bit-mask class templates have several drawbacks:</p>
+the implementation has to change to prevent undefined behavior. 
-
+Therefore, there are specializations of <code>low_bits_mask_t</code> at
-<ul>
+those bit counts.</p>
 	<li>You must know the valid bit-lengths in advance.</li>
 	<li>Using an inappropriate parameter value results in a compiler
 	    diagnostic.</li>
 	<li>The type names used are inconsistent with other transformations in
 	    Boost, like in <a href="../../mpl/">MPL</a>.</li>
 	<li>The above two facts make use of the regular bit-mask class templates
 	    incompatible with template meta-programming techniques.</li>
 </ul>
 <p>The <code>integer_hi_mask</code> and <code>integer_lo_mask</code> class
 templates provide MPL-compatible alternatives.  These alternatives have the
 form:</p>
 <blockquote><pre>
 template&lt; int <var>Size</var> &gt;
 struct <var>name</var>
 {
    static  bool const  is_specialized = <em>implementation_supplied</em>;
    static  int const   <var>switch_id</var> = <var>Size</var>;
    typedef <em>implementation_supplied</em>  type;
    typedef <em>implementation_supplied</em>  value_type;
    static  value_type const  value = <em>implementation_supplied</em>;
    // with other operations...
 };
 </pre></blockquote>
 <p>Only some of the members are always present.  The presence of other members
 and operations is flagged by the (always-present) <code>is_specialized</code>.</p>
 <table border="2" cellpadding="5" align="center">
 	<caption>Permanent Members of the MPL-Compatible Masking Class Template
 	         Types</caption>
 	<tr>
 		<th>Class Template Member</th>
 		<th>Meaning</th>
 	</tr>
 	<tr>
 		<td><code>is_specialized</code></td>
 		<td>Flag indicating when a particular template class instantiation is a
 		    valid meta-function (<code>true</code>) or not (<code>false</code>).</td>
 	</tr>
 	<tr>
 		<td><code><var>switch_id</var></code> (Actual name is template-specific.)</td>
 		<td>The value of the main control parameter, accessible even if the
 			template class instantiation is aliased.</td>
 	</tr>
 </table>
 <p>The optional members are based from inheriting from a <a
 href="../../mpl/doc/refmanual/integral-constant.html">MPL-style Integral
 Constant</a> type, but only if <code>is_specialized</code> is <code>true</code>.</p>
 <table border="2" cellpadding="5" align="center">
 	<caption>Optional Members of the MPL-Compatible Masking Types</caption>
 	<tr>
 		<th>Class Template Member</th>
 		<th>Meaning</th>
 	</tr>
 	<tr>
 		<td><code>value</code></td>
 		<td>The actual bit mask.</td>
 	</tr>
 	<tr>
 		<td><code>value_type</code></td>
 		<td>The type of the bit mask value.</td>
 	</tr>
 	<tr>
 		<td><code>type</code></td>
 		<td>The Integral Constant</a> implementation type, which should be
 			<code><a href="../../mpl/doc/refmanual/integral-c.html">boost::mpl::
 			integral_c</a>&lt; <var>value_type</var>, <var>value</var>
 			&gt;</code>.</td>
 	</tr>
 </table>
 <p>The Integral Constant prototype also adds the following operations:</p>
 <table border="2" cellpadding="5" align="center">
 	<caption>Optional Operations of the MPL-Compatible Masking Types</caption>
 	<tr>
 		<th>Operation (with <var>n</var> as a masking type)</th>
 		<th>Meaning</th>
 	</tr>
 	<tr>
 		<td><code>boost::mpl::next&lt; n &gt;::type</code></td>
 		<td><code>boost::mpl::next&lt; n::type &gt;::type</code>, i.e.
 			<code>boost::mpl::integral_c&lt; n::value_type, n::value + 1
 			&gt;</code>.</td>
 	</tr>
 	<tr>
 		<td><code>boost::mpl::prior&lt; n &gt;::type</code></td>
 		<td><code>boost::mpl::prior&lt; n::type &gt;::type</code>, i.e.
 			<code>boost::mpl::integral_c&lt; n::value_type, n::value - 1
 			&gt;</code>.</td>
 	</tr>
 	<tr>
 		<td><code>n::value_type const  c = n();</code></td>
 		<td><var>c</var> is set to <code>n::value</code>.</td>
 	</tr>
 </table>
 <p>The specifics for each masking class template are:</p>
 <table border="2" cellpadding="5" align="center">
 	<caption>Criteria for the MPL-Compatible Masking Types<br>
 	         (Everything besides the parameter ID is in name-space
 	         <code>boost</code> except where indicated.)</caption>
 	<tr>
 		<th>Class Template</th>
 		<th>Parameter Member ID</th>
 		<th>Classic Equivalent</th>
 		<th>Value Type</th>
 		<th>Value</th>
 		<th>Valid Range</th>
 	</tr>
 	<tr>
 		<td><code>integer_hi_mask</code></td>
 		<td><code>bit_offset</code></td>
 		<td><code>high_bit_mask_t</code></td>
 		<td><code>sized_integral &lt; bit_offset + 1, unsigned &gt;</code></td>
 		<td>2<sup><code>bit_offset</code></sup></td>
 		<td><code>0 &lt;= bit_offset &lt; std::numeric_limits&lt; uintmax_t &gt;::digits</code></td>
 	</tr>
 	<tr>
 		<td><code>integer_lo_mask</code></td>
 		<td><code>bit_count</code></td>
 		<td><code>low_bits_mask_t</code></td>
 		<td><code>sized_integral &lt; bit_count, unsigned &gt;</code></td>
 		<td>2<sup><code>bit_offset</code></sup> - 1</td>
 		<td><code>0 &lt;= bit_count &lt;= std::numeric_limits&lt; uintmax_t &gt;::digits</code></td>
 	</tr>
 </table>
 <h2><a name="example">Example</a></h2>
 <blockquote><pre>
-#include &lt;<a href="../../../boost/integer/integer_mask.hpp">boost/integer/integer_mask.hpp</a>&gt;
+#include &lt;boost/integer/integer_mask.hpp&gt;
 //...
@ -363,15 +196,16 @@ contaimination of values by the higher, unused bits.</p>
 <h2><a name="credits">Credits</a></h2>
 <p>The author of the Boost bit mask class templates is <a
-href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a>.</p>
+href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>
 <hr>
-<p>Revised July 29, 2008</p>
+<p>Revised September 23, 2001</p>
-<p>&copy; Copyright Daryle Walker 2001.  Use, modification, and distribution are
+<p>&copy; Copyright Daryle Walker 2001.  Permission to copy, use,
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
+modify, sell and distribute this document is granted provided this
-href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
+copyright notice appears in all copies.  This document is provided
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+&quot;as is&quot; without express or implied warranty, and with no claim
 as to its suitability for any purpose.</p>
 </body>
 </html>
--- a/doc/static_log2.html
+++ b/doc/static_log2.html
@ -1,125 +1,73 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <html>
 <head>
 <title>Binary Logarithm Template</title>
 </head>
 <body bgcolor="white" text="black">
-
+<h1><img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
 <h1><img src="../../../boost.png" alt="boost.png (6897 bytes)"
 align="middle" width="277" height="86">Binary Logarithm Template</h1>
 <p>The class template in <cite><a href="../../../boost/integer/static_log2.hpp">&lt;boost/integer/static_log2.hpp&gt;</a></cite> determines the position of the highest bit in a given value.  This facility is useful for solving generic programming problems.</p>
 <h2><a name="contents">Contents</a></h2>
 <ul>
 	<li><a href="#contents">Contents</a></li>
 	<li><a href="#synopsis">Synopsis</a></li>
 	<li><a href="#usage">Usage</a></li>
 	<li><a href="#example">Example</a></li>
 	<li><a href="#demo">Demonstration Program</a></li>
 	<li><a href="#rationale">Rationale</a></li>
 	<li><a href="#credits">Credits</a></li>
 	<li><a href="#whatsnew"><b>What's new</b></a></li>
 </ul>
 <h2><a name="synopsis">Synopsis</a></h2>
 <blockquote><pre>
 namespace boost
 {
-  typedef <em>implementation-defined</em> static_log2_argument_type;
+template &lt; unsigned long Value &gt;
-  typedef <em>implementation-defined</em> static_log2_result_type;
+struct static_log2
 {
    static const int  value = <em>implementation_defined</em>;
 };
-  template &lt; static_log2_argument_type arg &gt;
+template &lt; &gt;
-  struct static_log2
+struct static_log2&lt; 0ul &gt;
-  {
+{
    static const static_log2_result_type value = <em>implementation-defined</em>;
  };
  template &lt; &gt;
  struct static_log2&lt; 0 &gt;
  {
    // The logarithm of zero is undefined.
-  };
+};
 }  // namespace boost
 </pre></blockquote>
 <h2><a name="usage">Usage</a></h2>
 <p>The <code>boost::static_log2</code> class template takes one template
-parameter, a value of type <code>static_log2_argument_type</code>. The template
+parameter, a value of type <code>unsigned long</code>.  The template
-only defines one member, <code>value</code>, which gives the truncated
+only defines one member, <code>value</code>, that returns the truncated
-base-two logarithm of the template argument.</p>
+base-two logarithm of the template parameter.</p>
 <p>Since the logarithm of zero, for any base, is undefined, there is a
-specialization of <code>static_log2</code> for a template argument
+specialization of <code>static_log2</code> for a template parameter
 of zero.  This specialization has no members, so an attempt to use
 the base-two logarithm of zero results in a compile-time error.</p>
 <p>Note: <ul>
         <li><code>static_log2_argument_type</code> is an <i>unsigned integer
         type</i> (C++ standard, 3.9.1p3).</li>
         <li><code>static_log2_result_type</code> is an <i>integer type</i>
                 (C++ standard, 3.9.1p7).</li>
                 </ul>
 <h2><a name="example">Example</a></h2>
 <blockquote><pre>
 #include &lt;boost/integer/static_log2.hpp&gt;
-#include "boost/integer/static_log2.hpp"
+template &lt; unsigned long Value &gt;
 template &lt; boost::static_log2_argument_type value &gt;
 bool is_it_what()
 {
-    typedef boost::static_log2&lt;value&gt;  lb_type;
+    typedef boost::static_log2&lt;Value&gt;  lb_type;
    int  temp = lb_type::value;
    //...
    return (temp % 2) != 0;
 }
@ -129,87 +77,47 @@ int main()
 {
    bool  temp = is_it_what&lt;2000&gt;();
    //...
-# if 0
+
    #if 0
    temp = is_it_what&lt;0&gt;();  // would give an error
-# endif
+    #endif
    //...
    temp = is_it_what&lt;24&gt;();
    //...
 }
 </pre></blockquote>
 <h2><a name="demo">Demonstration Program</a></h2>
 <p>The program <a href="../test/static_log2_test.cpp">static_log2_test.cpp</a>
 is a simplistic demonstration of the results from instantiating various
 examples of the binary logarithm class template.</p>
 <h2><a name="rationale">Rationale</a></h2>
 <p>The base-two (binary) logarithm, abbreviated <dfn>lb</dfn>, function
-is occasionally used to give order-estimates of computer algorithms.
+is occasionally used to give order-estimates of computer algorithms. 
 The truncated logarithm can be considered the highest power-of-two in a
 value, which corresponds to the value's highest set bit (for binary
 integers).  Sometimes the highest-bit position could be used in generic
 programming, which requires the position to be statically (<i>i.e.</i>
 at compile-time) available.</p>
 <h2><a name="whatsnew">Changes from previous versions:</a></h2>
 <ul>
 <li><i>New in version 1.32.0:</i><br><br>
 The argument type and the result type of <code>boost::static_log2</code>
 are now typedef'd. Formerly, they were hardcoded as <code>unsigned long</code>
 and <code>int</code> respectively. Please, use the provided typedefs in new
 code (and update old code as soon as possible).
 </li>
 </ul>
 <h2><a name="credits">Credits</a></h2>
-
+<p>The author of the Boost binary logarithm class template is <a
-
+href="../../../people/daryle_walker.html">Daryle Walker</a>.  Giovanni Bajo
-<p>The original version of the Boost binary logarithm class template was
+added support for compilers without partial template specialization.</p>
 written by <a href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a>
 and then enhanced by Giovanni Bajo with support for compilers without
 partial template specialization. The current version was suggested,
 together with a reference implementation, by Vesa Karvonen. Gennaro Prota
 wrote the actual source file.
 </p>
 <hr>
 <p>Revised May 14, 2002</p>
-
+<p>&copy; Copyright Daryle Walker 2001.  Permission to copy, use,
-<p>Revised July 19, 2004</p>
+modify, sell and distribute this document is granted provided this
-
+copyright notice appears in all copies.  This document is provided
-          <p>&copy; Copyright Daryle Walker 2001.<br>
+&quot;as is&quot; without express or implied warranty, and with no claim
-             &copy; Copyright Gennaro Prota 2004.</p>
+as to its suitability for any purpose.</p>
     Distributed under the Boost Software License, Version 1.0.
        (See accompanying file LICENSE_1_0.txt or copy at
         <a href="http://www.boost.org/LICENSE_1_0.txt">
            http://www.boost.org/LICENSE_1_0.txt</a>)
 <br>
 </body>
 </html>
--- a/doc/static_min_max.html
+++ b/doc/static_min_max.html
@ -5,7 +5,7 @@
 </head>
 <body bgcolor="white" text="black" link="blue" alink="red" vlink="purple">
-<h1><img src="../../../boost.png" alt="boost.png (6897 bytes)"
+<h1><img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
 align="middle" width="277" height="86">Compile-Time Extrema
 Templates</h1>
@ -106,15 +106,16 @@ class template.</p>
 <h2><a name="credits">Credits</a></h2>
 <p>The author of the Boost compile-time extrema class templates is <a
-href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a>.</p>
+href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>
 <hr>
 <p>Revised October 12, 2001</p>
-<p>&copy; Copyright Daryle Walker 2001.  Use, modification, and distribution are
+<p>&copy; Copyright Daryle Walker 2001.  Permission to copy, use,
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
+modify, sell and distribute this document is granted provided this
-href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
+copyright notice appears in all copies.  This document is provided
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+&quot;as is&quot; without express or implied warranty, and with no claim
 as to its suitability for any purpose.</p>
 </body>
 </html>
--- a/include/boost/cstdint.hpp
+++ b/include/boost/cstdint.hpp
@ -1,13 +1,12 @@
 //  boost cstdint.hpp header file  ------------------------------------------//
-//  (C) Copyright Beman Dawes 1999. 
+//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
-//  (C) Copyright Jens Mauer 2001  
+//  and distribute this software is granted provided this copyright
-//  (C) Copyright John Maddock 2001 
+//  notice appears in all copies. This software is provided "as is" without
-//  Distributed under the Boost
+//  express or implied warranty, and with no claim as to its suitability for
-//  Software License, Version 1.0. (See accompanying file
+//  any purpose.
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//  See http://www.boost.org/libs/integer for documentation.
+//  See http://www.boost.org for most recent version including documentation.
 //  Revision History
 //   31 Oct 01  use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.)
@ -36,52 +35,12 @@
      // this is triggered with GCC, because it defines __cplusplus < 199707L
 #     define BOOST_NO_INT64_T
 #   endif 
-# elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX)
+# elif defined(__FreeBSD__)
 #   include <inttypes.h>
 # else
 #   include <stdint.h>
 // There is a bug in Cygwin two _C macros
 #   if defined(__STDC_CONSTANT_MACROS) && defined(__CYGWIN__)
 #     undef INTMAX_C
 #     undef UINTMAX_C
 #     define INTMAX_C(c) c##LL
 #     define UINTMAX_C(c) c##ULL
 #   endif
 # endif
 #ifdef __QNX__
 // QNX (Dinkumware stdlib) defines these as non-standard names.
 // Reflect to the standard names.
 typedef ::intleast8_t int_least8_t;
 typedef ::intfast8_t int_fast8_t;
 typedef ::uintleast8_t uint_least8_t;
 typedef ::uintfast8_t uint_fast8_t;
 typedef ::intleast16_t int_least16_t;
 typedef ::intfast16_t int_fast16_t;
 typedef ::uintleast16_t uint_least16_t;
 typedef ::uintfast16_t uint_fast16_t;
 typedef ::intleast32_t int_least32_t;
 typedef ::intfast32_t int_fast32_t;
 typedef ::uintleast32_t uint_least32_t;
 typedef ::uintfast32_t uint_fast32_t;
 # ifndef BOOST_NO_INT64_T
 typedef ::intleast64_t int_least64_t;
 typedef ::intfast64_t int_fast64_t;
 typedef ::uintleast64_t uint_least64_t;
 typedef ::uintfast64_t uint_fast64_t;
 # endif
 #endif
 namespace boost
 {
@ -122,8 +81,8 @@ namespace boost
 } // namespace boost
-#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__)
+#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4)
-// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
+// FreeBSD has an <inttypes.h> that contains much of what we need
 # include <inttypes.h>
 namespace boost {
@ -172,8 +131,7 @@ namespace boost {
 #else  // BOOST_HAS_STDINT_H
-# include <boost/limits.hpp> // implementation artifact; not part of interface
+# include <limits.h> // implementation artifact; not part of interface
 # include <limits.h>         // needed for limits macros
 namespace boost
@ -203,29 +161,12 @@ namespace boost
 //  16-bit types  -----------------------------------------------------------//
 # if USHRT_MAX == 0xffff
 #  if defined(__crayx1)
     // The Cray X1 has a 16-bit short, however it is not recommend
     // for use in performance critical code.
     typedef short           int16_t;
     typedef short           int_least16_t;
     typedef int             int_fast16_t;
     typedef unsigned short  uint16_t;
     typedef unsigned short  uint_least16_t;
     typedef unsigned int    uint_fast16_t;
 #  else
     typedef short           int16_t;
     typedef short           int_least16_t;
     typedef short           int_fast16_t;
     typedef unsigned short  uint16_t;
     typedef unsigned short  uint_least16_t;
     typedef unsigned short  uint_fast16_t;
 #  endif
 # elif (USHRT_MAX == 0xffffffff) && defined(CRAY)
     // no 16-bit types on Cray:
     typedef short           int_least16_t;
     typedef short           int_fast16_t;
     typedef unsigned short  uint_least16_t;
     typedef unsigned short  uint_fast16_t;
 # else
 #    error defaults not correct; you must hand modify boost/cstdint.hpp
 # endif
@ -264,14 +205,14 @@ namespace boost
 #       error defaults not correct; you must hand modify boost/cstdint.hpp
 #    endif
-     typedef  ::boost::long_long_type            intmax_t;
+     typedef long long            intmax_t;
-     typedef  ::boost::ulong_long_type   uintmax_t;
+     typedef unsigned long long   uintmax_t;
-     typedef  ::boost::long_long_type            int64_t;
+     typedef long long            int64_t;
-     typedef  ::boost::long_long_type            int_least64_t;
+     typedef long long            int_least64_t;
-     typedef  ::boost::long_long_type            int_fast64_t;
+     typedef long long            int_fast64_t;
-     typedef  ::boost::ulong_long_type   uint64_t;
+     typedef unsigned long long   uint64_t;
-     typedef  ::boost::ulong_long_type   uint_least64_t;
+     typedef unsigned long long   uint_least64_t;
-     typedef  ::boost::ulong_long_type   uint_fast64_t;
+     typedef unsigned long long   uint_fast64_t;
 # elif ULONG_MAX != 0xffffffff
@ -287,15 +228,6 @@ namespace boost
 #    else
 #       error defaults not correct; you must hand modify boost/cstdint.hpp
 #    endif
 # elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG)
     __extension__ typedef long long            intmax_t;
     __extension__ typedef unsigned long long   uintmax_t;
     __extension__ typedef long long            int64_t;
     __extension__ typedef long long            int_least64_t;
     __extension__ typedef long long            int_fast64_t;
     __extension__ typedef unsigned long long   uint64_t;
     __extension__ typedef unsigned long long   uint_least64_t;
     __extension__ typedef unsigned long long   uint_fast64_t;
 # elif defined(BOOST_HAS_MS_INT64)
     //
     // we have Borland/Intel/Microsoft __int64:
@ -442,5 +374,3 @@ BOOST_HAS_STDINT_H is defined (John Maddock).
 #endif // __STDC_CONSTANT_MACROS_DEFINED etc.
--- a/include/boost/detail/extended_integer.hpp
+++ b/include/boost/detail/extended_integer.hpp
@ -1,177 +0,0 @@
 // Boost detail/extended_integer.hpp header file  ----------------------------//
 // (C) 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 <http://www.boost.org/LICENSE_1_0.txt>.)
 // Encapsulates the double-long and __int64 type families as a single family,
 // as they are mutually exclusive.
 /** \file
    \brief  Common definition of extended integer types.
    Instead of other Boost headers making separate \#defines for the double-long
    and __int64 type families, since they're mutually exclusive, make a single
    set of types and macros for the family that exists (if either).
 */
 #ifndef BOOST_DETAIL_EXTENDED_INTEGER_HPP
 #define BOOST_DETAIL_EXTENDED_INTEGER_HPP
 #include <boost/config.hpp>  // for BOOST_HAS_LONG_LONG and BOOST_HAS_MS_INT64
 #include <climits>  // for CHAR_BIT, etc.
 namespace boost
 {
 namespace detail
 {
 //  Extended integer type macro and alias definitions  -----------------------//
 // (Unsigned) long long family
 #ifdef BOOST_HAS_LONG_LONG
 // Existence
 #define BOOST_HAS_XINT  1
 // Extents
 #ifdef ULLONG_MAX
 #define BOOST_XINT_MAX    LLONG_MAX
 #define BOOST_XINT_MIN    LLONG_MIN
 #define BOOST_UXINT_MAX  ULLONG_MAX
 #elif defined(ULONG_LONG_MAX)
 #define BOOST_XINT_MAX    LONG_LONG_MAX
 #define BOOST_XINT_MIN    LONG_LONG_MIN
 #define BOOST_UXINT_MAX  ULONG_LONG_MAX
 #elif defined(ULONGLONG_MAX)
 #define BOOST_XINT_MAX    LONGLONG_MAX
 #define BOOST_XINT_MIN    LONGLONG_MIN
 #define BOOST_UXINT_MAX  ULONGLONG_MAX
 #elif defined(_LLONG_MAX) && defined(_C2)
 #define BOOST_XINT_MAX    _LLONG_MAX
 #define BOOST_XINT_MIN    (-_LLONG_MAX - _C2)
 #define BOOST_UXINT_MAX  _ULLONG_MAX
 #else  // guess
 // Sometimes we get the double-long types without the corresponding constants,
 // e.g. GCC in "-ansi" mode.  In this case, we'll just have to work out the
 // values ourselves.  (Here we assume a two's complement representation.)
 #define BOOST_XINT_MIN   (1LL << (sizeof(::boost::long_long_type) * CHAR_BIT - 1))
 #define BOOST_XINT_MAX   (~ BOOST_XINT_MIN)
 #define BOOST_UXINT_MAX  (~ 0uLL)
 #endif
 // Types
 typedef ::boost:: long_long_type   xint_t;
 typedef ::boost::ulong_long_type  uxint_t;
 // (Unsigned) __int64 family
 #elif defined(BOOST_HAS_MS_INT64)
 // Existence
 #define BOOST_HAS_XINT  1
 // Extents
 #ifdef _UI64_MAX
 #define BOOST_XINT_MAX    _I64_MAX
 #define BOOST_XINT_MIN    _I64_MIN
 #define BOOST_UXINT_MAX  _UI64_MAX
 #else  // guess
 // The types are exactly 2's-compl. 64-bit, so we'll enter the values directly.
 #define BOOST_XINT_MAX   0x7FFFFFFFFFFFFFFFi64
 #define BOOST_XINT_MIN   0x8000000000000000i64
 #define BOOST_UXINT_MAX  0xFFFFFFFFFFFFFFFFui64
 #endif
 // Types
 typedef          __int64   xint_t;
 typedef unsigned __int64  uxint_t;
 // Neither
 #else
 // Non-existence
 #define BOOST_HAS_XINT  0
 // Dummy extents
 #define BOOST_XINT_MAX    LONG_MAX
 #define BOOST_XINT_MIN    LONG_MIN
 #define BOOST_UXINT_MAX  ULONG_MAX
 // Dummy types
 typedef   signed long   xint_t;
 typedef unsigned long  uxint_t;
 #endif  // defined(BOOST_HAS_LONG_LONG)/defined(BOOST_HAS_MS_INT64)/else
 /** \def  BOOST_HAS_XINT
    \brief  Flag for extended integer types.
    Indicates the presence of one of the two common extended integer type
    families, either (<code>unsigned</code>) <code>long long</code> or
    (<code>unsigned</code>) <code>__int64</code>.  \c BOOST_HAS_XINT is \c 1 if
    either type family is defined, and \c 0 if neither is.
 */
 /** \def  BOOST_XINT_MAX
    \brief  Maximum value for the signed extended integer type.
    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
    Macro constant representing the largest value the signed extended integer
    type supports.  Its composition may be another macro, an expression, or a
    literal.  Defaulted to \c LONG_MAX if \c BOOST_HAS_XINT is zero.
 */
 /** \def  BOOST_XINT_MIN
    \brief  Minimum value for the signed extended integer type.
    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
    Macro constant representing the smallest value the signed extended integer
    type supports.  Its composition may be another macro, an expression, or a
    literal.  Defaulted to \c LONG_MIN if \c BOOST_HAS_XINT is zero.
 */
 /** \def  BOOST_UXINT_MAX
    \brief  Maximum value for the unsigned extended integer type.
    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
    Macro constant representing the largest value the unsigned extended integer
    type supports.  Its composition may be another macro, an expression, or a
    literal.  Defaulted to \c ULONG_MAX if \c BOOST_HAS_XINT is zero.  (Use
    \c 0u for the type's minimum value.)
 */
 /** \typedef  signed long  boost::detail::xint_t
    \brief  Alias for the signed extended integer type.
    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
    Alias representing the signed extended integer type, no matter which type
    family it came from.  Defaulted to <code>signed long</code> if
    \c BOOST_HAS_XINT is zero.
 */
 /** \typedef  unsigned long  ::boost::detail::uxint_t
    \brief  Alias for the signed extended integer type.
    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
    Alias representing the unsigned extended integer type, no matter which type
    family it came from.  Defaulted to <code>unsigned long</code> if
    \c BOOST_HAS_XINT is zero.
 */
 }  // namespace detail
 }  // namespace boost
 #endif  // BOOST_DETAIL_EXTENDED_INTEGER_HPP
--- a/include/boost/integer.hpp
+++ b/include/boost/integer.hpp
@ -1,18 +1,14 @@
 //  boost integer.hpp header file  -------------------------------------------//
-//  Copyright Beman Dawes and Daryle Walker 1999.  Distributed under the Boost
+//  (C) Copyright Beman Dawes 1999. Permission to copy, use, modify, sell
-//  Software License, Version 1.0. (See accompanying file
+//  and distribute this software is granted provided this copyright
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  notice appears in all copies. This software is provided "as is" without
 //  express or implied warranty, and with no claim as to its suitability for
 //  any purpose.
-//  See http://www.boost.org/libs/integer for documentation.
+//  See http://www.boost.org for most recent version including 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  Added extended-integer support. (Daryle Walker)
 //   13 Jul 08  Redid implmentation. (Daryle Walker)
 //   22 Sep 01  Added value-based integer templates. (Daryle Walker)
 //   01 Apr 01  Modified to use new <boost/limits.hpp> header. (John Maddock)
 //   30 Jul 00  Add typename syntax fix (Jens Maurer)
@ -23,357 +19,108 @@
 #include <boost/integer_fwd.hpp>  // self include
-#include <boost/config.hpp>             // for BOOST_STATIC_CONSTANT, etc.
+#include <boost/integer_traits.hpp>  // for boost::integer_traits
-#include <boost/cstdint.hpp>            // for boost::uintmax_t, intmax_t
+#include <boost/limits.hpp>          // for std::numeric_limits
 #include <boost/integer_traits.hpp>     // for boost::integer_traits
 #include <boost/limits.hpp>             // for std::numeric_limits
 #include <boost/utility/enable_if.hpp>  // for boost::enable_if_c
 #include <boost/detail/extended_integer.hpp>  // for BOOST_HAS_XINT, etc.
 #include <climits>  // for UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, etc.
 namespace boost
 {
-  //  integer template mapping a type to its processor-optimized analog  -----//
+  //  Helper templates  ------------------------------------------------------//
  //  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.
  //  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<LeastInt>::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  ------------------------------------------------------//
+  //  specializatons: 1=long, 2=int, 3=short, 4=signed char,
-
+  //     6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned long
-  //  convert integer category to type ; default is empty
+  //  no specializations for 0 and 5: requests for a type > long are in error
-  template< int Rank, typename Signedness > struct  int_least_helper {};
+  template<> struct int_least_helper<1> { typedef long least; };
-
+  template<> struct int_least_helper<2> { typedef int least; };
-  //  specializatons: 1=(unsigned) __int64/long long, 2=(unsigned) long,
+  template<> struct int_least_helper<3> { typedef short least; };
-  //     3=unsigned/int, 4=(unsigned) short, 5=(un)signed char
+  template<> struct int_least_helper<4> { typedef signed char least; };
-  //  no specializations for 0: requests for a type > (unsigned) (long) long are
+  template<> struct int_least_helper<6> { typedef unsigned long least; };
-  //     in error
+  template<> struct int_least_helper<7> { typedef unsigned int least; };
-#if BOOST_HAS_XINT
+  template<> struct int_least_helper<8> { typedef unsigned short least; };
-  template<> struct int_least_helper<1,   signed>  { typedef  xint_t least; };
+  template<> struct int_least_helper<9> { typedef unsigned char 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<std::numeric_limits< Type >::digits + 1> \
  { BOOST_STATIC_CONSTANT( int, rank = Rank ); }
 #define BOOST_PRIVATE_UINT_EXACT_BUILDER(Type, Rank) \
  template < > \
  struct uint_exact_rank_helper<std::numeric_limits< Type >::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<BitsIncludingSign>::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<Bits>::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<BitsIncludingSign>::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<Bits>::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<MaxValue>::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<MinValue>::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<Value>::rank, unsigned >
  {
      BOOST_STATIC_CONSTANT( uintmax_t, bound = Value );
  };
  //  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<Bits, signed>::type  least;
+      typedef typename int_least_helper
-      typedef typename int_fast_t<least>::fast             fast;
+        <
-  };
+          (Bits-1 <= std::numeric_limits<long>::digits) +
-
+          (Bits-1 <= std::numeric_limits<int>::digits) +
-  template< int Bits >   // exact bits (including sign) desired
+          (Bits-1 <= std::numeric_limits<short>::digits) +
-  struct int_exact_t
+          (Bits-1 <= std::numeric_limits<signed char>::digits)
-  {
+        >::least  least;
-      typedef typename exact_integral<Bits, signed>::type  exact;
+      typedef typename int_fast_t<least>::fast  fast;
  };
  //  unsigned
-  template< int Bits >   // minimum bits required
+  template< int Bits >   // bits required
  struct uint_t 
  {
-      typedef typename sized_integral<Bits, unsigned>::type  least;
+      typedef typename int_least_helper
-      typedef typename int_fast_t<least>::fast               fast;
+        < 
          5 +
          (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)
        >::least  least;
      typedef typename int_fast_t<least>::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<Bits, unsigned>::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<MaxValue>::type  least;
+      typedef typename int_least_helper
-      typedef typename int_fast_t<least>::fast                  fast;
+        <
          (MaxValue <= integer_traits<long>::const_max) +
          (MaxValue <= integer_traits<int>::const_max) +
          (MaxValue <= integer_traits<short>::const_max) +
          (MaxValue <= integer_traits<signed char>::const_max)
        >::least  least;
      typedef typename int_fast_t<least>::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<MinValue>::type  least;
+      typedef typename int_least_helper
-      typedef typename int_fast_t<least>::fast                  fast;
+        <
          (MinValue >= integer_traits<long>::const_min) +
          (MinValue >= integer_traits<int>::const_min) +
          (MinValue >= integer_traits<short>::const_min) +
          (MinValue >= integer_traits<signed char>::const_min)
        >::least  least;
      typedef typename int_fast_t<least>::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<Value>::type  least;
+      typedef typename int_least_helper
-      typedef typename int_fast_t<least>::fast                 fast;
+        < 
          5 +
          (Value <= integer_traits<unsigned long>::const_max) +
          (Value <= integer_traits<unsigned int>::const_max) +
          (Value <= integer_traits<unsigned short>::const_max) +
          (Value <= integer_traits<unsigned char>::const_max)
        >::least  least;
      typedef typename int_fast_t<least>::fast  fast;
  };
--- a/include/boost/integer/integer_mask.hpp
+++ b/include/boost/integer/integer_mask.hpp
@ -1,9 +1,9 @@
 //  Boost integer/integer_mask.hpp header file  ------------------------------//
-//  (C) Copyright Daryle Walker 2001.
+//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell and
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  distribute this software is granted provided this copyright notice appears 
-//  accompanying file LICENSE_1_0.txt or copy at
+//  in all copies.  This software is provided "as is" without express or
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  implied warranty, and with no claim as to its suitability for any purpose. 
 //  See http://www.boost.org for updates, documentation, and revision history. 
@ -12,192 +12,81 @@
 #include <boost/integer_fwd.hpp>  // self include
-#include <boost/config.hpp>             // for BOOST_STATIC_CONSTANT
+#include <boost/config.hpp>   // for BOOST_STATIC_CONSTANT
-#include <boost/cstdint.hpp>            // for boost::uintmax_t
+#include <boost/integer.hpp>  // for boost::uint_t
 #include <boost/integer.hpp>            // for boost::sized_integral
 #include <boost/limits.hpp>             // for std::numeric_limits
 #include <boost/mpl/and.hpp>            // for boost::mpl::and_
 #include <boost/mpl/bitwise.hpp>        // for boost::mpl::bitor_, shift_left
 #include <boost/mpl/bool.hpp>           // for boost::mpl::true_
 #include <boost/mpl/comparison.hpp>     // for boost::mpl::greater_equal, etc.
 #include <boost/mpl/empty_base.hpp>     // for boost::mpl::empty_base
 #include <boost/mpl/if.hpp>             // for boost::mpl::if_
 #include <boost/mpl/int.hpp>            // for boost::mpl::int_
 #include <boost/mpl/integral_c.hpp>     // for boost::integral_c
 #include <boost/mpl/next_prior.hpp>     // for boost::mpl::next, prior
 #include <boost/utility/enable_if.hpp>  // for boost::enable_if
 #include <climits>  // for UCHAR_MAX, etc.
 #include <cstddef>  // for std::size_t
 #include <boost/limits.hpp>  // for std::numeric_limits
 namespace boost
 {
 namespace detail
 {
 //  Helper templates  --------------------------------------------------------//
 template < int Bits >
 struct hi_integer_mask_builder1
 {
    typedef boost::mpl::int_<Bits>  bit_count_type;
    typedef typename boost::mpl::next<bit_count_type>::type
      mask_length_type;
    typedef boost::sized_integral<mask_length_type::value, unsigned>
      mask_type;
    typedef boost::mpl::integral_c<typename mask_type::type, 1>  one_type;
    typedef boost::mpl::shift_left<one_type, bit_count_type>  result_type;
 };
 template < int Bits >
 struct hi_integer_mask_builder2
 {
    typedef boost::mpl::int_<Bits>  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_<std::numeric_limits<boost::uintmax_t>::digits> >
      hi_bound_type;
    typedef boost::mpl::and_<lo_bound_type, hi_bound_type>  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<typename
 hi_integer_mask_builder2<Bits>::count_valid_type>::type >
    : hi_integer_mask_builder1<Bits>::result_type
 {
    BOOST_STATIC_CONSTANT( bool, is_specialized = true );
 };
 template < int Bits >
 struct lo_integer_mask_builder1
 {
    typedef boost::mpl::int_<Bits>  bit_count_type;
    typedef typename boost::mpl::prior<bit_count_type>::type
      shift_length_type;
    typedef boost::sized_integral<bit_count_type::value, unsigned>
      mask_type;
    typedef boost::mpl::integral_c<typename mask_type::type, 1>  one_type;
    typedef boost::mpl::shift_left<one_type, shift_length_type>
      high_bit_type;
    typedef typename boost::mpl::prior<high_bit_type>::type  low_bits_type;
    typedef boost::mpl::bitor_<high_bit_type, low_bits_type>  result_type;
 };
 template <  >
 struct lo_integer_mask_builder1< 0 >
 {
    // Let's not deal with negative interim values....
    typedef boost::mpl::integral_c<unsigned char, 0u>  result_type;
 };
 template < int Bits >
 struct lo_integer_mask_builder2
 {
    typedef boost::mpl::int_<Bits>  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_<std::numeric_limits<boost::uintmax_t>::digits> >
      hi_bound_type;
    typedef boost::mpl::and_<lo_bound_type, hi_bound_type>  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<typename
 lo_integer_mask_builder2<Bits>::count_valid_type>::type >
    : lo_integer_mask_builder1<Bits>::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<Offset>
 {
    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<Length>
 {
    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<Bit>  impl_type;
+    typedef typename uint_t<(Bit + 1)>::least  least;
    typedef typename uint_t<(Bit + 1)>::fast   fast;
-public:
+    BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << Bit) );
-    typedef typename impl_type::value_type   least;
+    BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << Bit) );
    typedef typename int_fast_t<least>::fast  fast;
-    BOOST_STATIC_CONSTANT( least, high_bit = impl_type::value );
+    BOOST_STATIC_CONSTANT( std::size_t, bit_position = Bit );
    BOOST_STATIC_CONSTANT( fast, high_bit_fast = impl_type::value );
    BOOST_STATIC_CONSTANT( std::size_t, bit_position = impl_type::bit_offset );
 };  // 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<Bits>  impl_type;
+    typedef typename uint_t<Bits>::least  least;
    typedef typename uint_t<Bits>::fast   fast;
-public:
+    BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
-    typedef typename impl_type::value_type   least;
+    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
    typedef typename int_fast_t<least>::fast  fast;
-    BOOST_STATIC_CONSTANT( least, sig_bits = impl_type::value );
+    BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = impl_type::value );
    BOOST_STATIC_CONSTANT( std::size_t, bit_count = impl_type::bit_count );
 };  // boost::low_bits_mask_t
 #define BOOST_LOW_BITS_MASK_SPECIALIZE( Type )                                  \
  template <  >  struct low_bits_mask_t< std::numeric_limits<Type>::digits >  { \
      typedef std::numeric_limits<Type>           limits_type;                  \
      typedef uint_t<limits_type::digits>::least  least;                        \
      typedef uint_t<limits_type::digits>::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
--- a/include/boost/integer/static_log2.hpp
+++ b/include/boost/integer/static_log2.hpp
@ -1,132 +1,141 @@
-// -------------- Boost static_log2.hpp header file  ----------------------- //
+//  Boost integer/static_log2.hpp header file  -------------------------------//
 //
 //                 Copyright (C) 2001 Daryle Walker.
 //                 Copyright (C) 2003 Vesa Karvonen.
 //                 Copyright (C) 2003 Gennaro Prota.
 //
 //     Distributed under the Boost 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.
 // ------------------------------------------------------------------------- //
 //  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell and
 //  distribute this software is granted provided this copyright notice appears 
 //  in all copies.  This software is provided "as is" without express or
 //  implied warranty, and with no claim as to its suitability for any purpose. 
 //  See http://www.boost.org for updates, documentation, and revision history. 
 #ifndef BOOST_INTEGER_STATIC_LOG2_HPP
 #define BOOST_INTEGER_STATIC_LOG2_HPP
-#include "boost/config.hpp" // for BOOST_STATIC_CONSTANT
+#include <boost/integer_fwd.hpp>  // self include
-namespace boost {
+#include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT, etc.
 #include <boost/limits.hpp>  // for std::numeric_limits
- namespace detail {
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
+#include <boost/pending/ct_if.hpp>  // for boost::ct_if<>
-     namespace static_log2_impl {
+#endif
     // choose_initial_n<>
     //
     // Recursively doubles its integer argument, until it
     // becomes >= of the "width" (C99, 6.2.6.2p4) of
     // static_log2_argument_type.
     //
     // Used to get the maximum power of two less then the width.
     //
     // Example: if on your platform argument_type has 48 value
     //          bits it yields n=32.
     //
     // It's easy to prove that, starting from such a value
     // of n, the core algorithm works correctly for any width
     // of static_log2_argument_type and that recursion always
     // terminates with x = 1 and n = 0 (see the algorithm's
     // invariant).
     typedef unsigned long argument_type;
     typedef          int  result_type;
-     template <result_type n>
+namespace boost
-     struct choose_initial_n {
+{
         enum { c = (argument_type(1) << n << n) != 0 };
         BOOST_STATIC_CONSTANT(
             result_type,
             value = !c*n + choose_initial_n<2*c*n>::value
         );
     };
     template <>
     struct choose_initial_n<0> {
         BOOST_STATIC_CONSTANT(result_type, value = 0);
     };
 //  Implementation details  --------------------------------------------------//
-     // start computing from n_zero - must be a power of two
+namespace detail
-     const result_type n_zero = 16;
+{
     const result_type initial_n = choose_initial_n<n_zero>::value;
-     // static_log2_impl<>
+// Forward declarations
-     //
+template < unsigned long Val, int Place = 0, int Index
-     // * Invariant:
+ = std::numeric_limits<unsigned long>::digits >
-     //                 2n
+    struct static_log2_helper_t;
     //  1 <= x && x < 2    at the start of each recursion
     //                     (see also choose_initial_n<>)
     //
     // * Type requirements:
     //
     //   argument_type maybe any unsigned type with at least n_zero + 1
     //   value bits. (Note: If larger types will be standardized -e.g.
     //   unsigned long long- then the argument_type typedef can be
     //   changed without affecting the rest of the code.)
     //
-     template <argument_type x, result_type n = initial_n>
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     struct static_log2_impl {
-         enum { c = (x >> n) > 0 }; // x >= 2**n ?
+template < unsigned long Val, int Place >
-         BOOST_STATIC_CONSTANT(
+    struct static_log2_helper_t< Val, Place, 1 >;
             result_type,
             value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)
         );
-     };
+#else
-     template <>
+template < int Place >
-     struct static_log2_impl<1, 0> {
+    struct static_log2_helper_final_step;
        BOOST_STATIC_CONSTANT(result_type, value = 0);
     };
-     }
+template < unsigned long Val, int Place = 0, int Index
- } // detail
+ = std::numeric_limits<unsigned long>::digits >
    struct static_log2_helper_nopts_t;
 #endif
 // Recursively build the logarithm by examining the upper bits
 template < unsigned long Val, int Place, int Index >
 struct static_log2_helper_t
 {
 private:
    BOOST_STATIC_CONSTANT( int, half_place = Index / 2 );
    BOOST_STATIC_CONSTANT( unsigned long, lower_mask = (1ul << half_place)
     - 1ul );
    BOOST_STATIC_CONSTANT( unsigned long, upper_mask = ~lower_mask );
    BOOST_STATIC_CONSTANT( bool, do_shift = (Val & upper_mask) != 0ul );
    BOOST_STATIC_CONSTANT( unsigned long, new_val = do_shift ? (Val
     >> half_place) : Val );
    BOOST_STATIC_CONSTANT( int, new_place = do_shift ? (Place + half_place)
     : Place );
    BOOST_STATIC_CONSTANT( int, new_index = Index - half_place );
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    typedef static_log2_helper_t<new_val, new_place, new_index>  next_step_type;
 #else
    typedef static_log2_helper_nopts_t<new_val, new_place, new_index>  next_step_type;
 #endif
 public:
    BOOST_STATIC_CONSTANT( int, value = next_step_type::value );
 };  // boost::detail::static_log2_helper_t
 // Non-recursive case
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template < unsigned long Val, int Place >
 struct static_log2_helper_t< Val, Place, 1 >
 {
 public:
    BOOST_STATIC_CONSTANT( int, value = Place );
 };  // boost::detail::static_log2_helper_t
 #else
 template < int Place >
 struct static_log2_helper_final_step
 {
 public:
    BOOST_STATIC_CONSTANT( int, value = Place );
 };  // boost::detail::static_log2_helper_final_step
 template < unsigned long Val, int Place, int Index >
 struct static_log2_helper_nopts_t
 {
 private:
    typedef static_log2_helper_t<Val, Place, Index>  recursive_step_type;
    typedef static_log2_helper_final_step<Place>     final_step_type;
    typedef typename ct_if<( Index != 1 ), recursive_step_type,
     final_step_type>::type  next_step_type;
 public:
    BOOST_STATIC_CONSTANT( int, value = next_step_type::value );
 };  // boost::detail::static_log2_helper_nopts_t
 #endif
 }  // namespace detail
 //  Compile-time log-base-2 evaluator class declaration  ---------------------//
- // --------------------------------------
+template < unsigned long Value >
- // static_log2<x>
+struct static_log2
- // ----------------------------------------
+{
    BOOST_STATIC_CONSTANT( int, value
     = detail::static_log2_helper_t<Value>::value );
 };
- typedef detail::static_log2_impl::argument_type static_log2_argument_type;
+template < >
- typedef detail::static_log2_impl::result_type   static_log2_result_type;
+struct static_log2< 0ul >
 {
    // The logarithm of zero is undefined.
 };
- template <static_log2_argument_type x>
+}  // namespace boost
 struct static_log2 {
     BOOST_STATIC_CONSTANT(
         static_log2_result_type,
         value = detail::static_log2_impl::static_log2_impl<x>::value
     );
 };
- template <>
+#endif  // BOOST_INTEGER_STATIC_LOG2_HPP
 struct static_log2<0> { };
 }
 #endif // include guard
--- a/include/boost/integer/static_min_max.hpp
+++ b/include/boost/integer/static_min_max.hpp
@ -1,9 +1,10 @@
 //  Boost integer/static_min_max.hpp header file  ----------------------------//
-//  (C) Copyright Daryle Walker 2001.
+//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  and distribute this software is granted provided this copyright notice
-//  accompanying file LICENSE_1_0.txt or copy at
+//  appears in all copies.  This software is provided "as is" without
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  express or implied warranty, and with no claim as to its suitability
 //  for any purpose. 
 //  See http://www.boost.org for updates, documentation, and revision history. 
--- a/include/boost/integer_fwd.hpp
+++ b/include/boost/integer_fwd.hpp
@ -1,20 +1,21 @@
 //  Boost integer_fwd.hpp header file  ---------------------------------------//
-//  (C) Copyright Dave Abrahams and Daryle Walker 2001. Distributed under the Boost
+//  (C) Copyright boost.org 2001.  Permission to copy, use, modify, sell
-//  Software License, Version 1.0. (See accompanying file
+//  and distribute this software is granted provided this copyright
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  notice appears in all copies.  This software is provided "as is" without
 //  express or implied warranty, and with no claim as to its suitability for
 //  any purpose.
-//  See http://www.boost.org/libs/integer for documentation.
+//  See http://www.boost.org for most recent version including documentation.
 #ifndef BOOST_INTEGER_FWD_HPP
 #define BOOST_INTEGER_FWD_HPP
 #include <climits>  // for UCHAR_MAX, etc.
 #include <cstddef>  // for std::size_t
-#include <boost/config.hpp>   // for BOOST_NO_INTRINSIC_WCHAR_T, etc.
+#include <boost/config.hpp>  // for BOOST_NO_INTRINSIC_WCHAR_T
-#include <boost/cstdint.hpp>  // for boost::uintmax_t, intmax_t
+#include <boost/limits.hpp>  // for std::numeric_limits
 #include <boost/detail/extended_integer.hpp>  // for BOOST_HAS_XINT, etc.
 namespace boost
@ -25,13 +26,6 @@ namespace boost
 // Only has typedefs or using statements, with #conditionals
 // ALERT: the forward declarations of items in <boost/integer.hpp> need items
 // from this header.  That means that <boost/cstdint.hpp> 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), <boost/integer.hpp> will use
 // that header, and <boost/cstdint.hpp> could refer to <boost/integer.hpp>.
 //  From <boost/integer_traits.hpp>  -----------------------------------------//
@ -73,73 +67,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< long long >;
 template <  >
-    class integer_traits< ::boost::detail::uxint_t >;
+    class integer_traits< unsigned long long >;
 #endif
 //  From <boost/integer.hpp>  ------------------------------------------------//
 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 >
+template< long MaxValue >
    struct uint_exact_t;
 template< intmax_t 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 <boost/integer/integer_mask.hpp>  -----------------------------------//
 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<unsigned char>::digits >;
 #if USHRT_MAX > UCHAR_MAX
 template <  >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned short>::digits >;
 #endif
 #if UINT_MAX > USHRT_MAX
 template <  >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned int>::digits >;
 #endif
 #if ULONG_MAX > UINT_MAX
 template <  >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned long>::digits >;
 #endif
 //  From <boost/integer/static_log2.hpp>  ------------------------------------//
--- a/include/boost/integer_traits.hpp
+++ b/include/boost/integer_traits.hpp
@ -1,18 +1,20 @@
 /* boost integer_traits.hpp header file
 *
 * Copyright Jens Maurer 2000
- * Distributed under the Boost Software License, Version 1.0. (See
+ * Permission to use, copy, modify, sell, and distribute this software
- * accompanying file LICENSE_1_0.txt or copy at
+ * is hereby granted without fee provided that the above copyright notice
- * http://www.boost.org/LICENSE_1_0.txt)
+ * appears in all copies and that both that copyright notice and this
 * permission notice appear in supporting documentation,
 *
 * Jens Maurer makes no representations about the suitability of this
 * software for any purpose. It is provided "as is" without express or
 * implied warranty.
 *
 * $Id$
 *
 * Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers
 */
 //  See http://www.boost.org/libs/integer for documentation.
 #ifndef BOOST_INTEGER_TRAITS_HPP
 #define BOOST_INTEGER_TRAITS_HPP
@ -21,14 +23,10 @@
 // These are an implementation detail and not part of the interface
 #include <limits.h>
-// we need wchar.h for WCHAR_MAX/MIN but not all platforms provide it,
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && !defined(BOOST_NO_CWCHAR)
 // and some may have <wchar.h> but not <cwchar> ...
 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && (!defined(BOOST_NO_CWCHAR) || defined(sun) || defined(__sun) || defined(__QNX__))
 #include <wchar.h>
 #endif
 #include <boost/detail/extended_integer.hpp>  // for BOOST_HAS_XINT, etc.
 namespace boost {
 template<class T>
@ -90,25 +88,17 @@ class integer_traits<unsigned char>
 template<>
 class integer_traits<wchar_t>
  : public std::numeric_limits<wchar_t>,
-    // Don't trust WCHAR_MIN and WCHAR_MAX with Mac OS X's native
+#if defined(WCHAR_MIN) && defined(WCHAR_MAX)
    // library: they are wrong!
 #if defined(WCHAR_MIN) && defined(WCHAR_MAX) && !defined(__APPLE__)
    public detail::integer_traits_base<wchar_t, WCHAR_MIN, WCHAR_MAX>
 #elif defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
    // No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned:
    public detail::integer_traits_base<wchar_t, 0, 0xffff>
-#elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400))\
+#elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400)) || (defined __APPLE__) || (defined(__FreeBSD__) && defined(__GNUC__)) || (defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 3) && !defined(__SGI_STL_PORT))
    || (defined __APPLE__)\
    || (defined(__OpenBSD__) && defined(__GNUC__))\
    || (defined(__NetBSD__) && defined(__GNUC__))\
    || (defined(__FreeBSD__) && defined(__GNUC__))\
    || (defined(__DragonFly__) && defined(__GNUC__))\
    || (defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 3) && !defined(__SGI_STL_PORT))
    // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as int.
    //  - SGI MIPSpro with native library
    //  - gcc 3.x on HP-UX
    //  - Mac OS X with native library
-    //  - gcc on FreeBSD, OpenBSD and NetBSD
+    //  - gcc on FreeBSD
    public detail::integer_traits_base<wchar_t, INT_MIN, INT_MAX>
 #elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT)
    // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int.
@ -157,17 +147,38 @@ class integer_traits<unsigned long>
    public detail::integer_traits_base<unsigned long, 0, ULONG_MAX>
 { };
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && BOOST_HAS_XINT
+#if defined(ULLONG_MAX) && !defined(__SUNPRO_CC)
 template<>
-class integer_traits< detail::xint_t >
+class integer_traits<long long>
-  : public std::numeric_limits< detail::xint_t >,
+  : public std::numeric_limits<long long>,
-    public detail::integer_traits_base< detail::xint_t, BOOST_XINT_MIN, BOOST_XINT_MAX >
+    public detail::integer_traits_base<long long, LLONG_MIN, LLONG_MAX>
 { };
 template<>
-class integer_traits< detail::uxint_t >
+class integer_traits<unsigned long long>
-  : public std::numeric_limits< detail::uxint_t >,
+  : public std::numeric_limits<unsigned long long>,
-    public detail::integer_traits_base< detail::uxint_t, 0u, BOOST_UXINT_MAX >
+    public detail::integer_traits_base<unsigned long long, 0, ULLONG_MAX>
 { };
 #elif defined(ULONG_LONG_MAX)
 template<>
 class integer_traits<long long>
  : public std::numeric_limits<long long>,
    public detail::integer_traits_base<long long, LONG_LONG_MIN, LONG_LONG_MAX>
 { };
 template<>
 class integer_traits<unsigned long long>
  : public std::numeric_limits<unsigned long long>,
    public detail::integer_traits_base<unsigned long long, 0, ULONG_LONG_MAX>
 { };
 #elif defined(ULONGLONG_MAX) && !defined(BOOST_MSVC) && !defined(__BORLANDC__)
 template<>
 class integer_traits<long long>
  : public std::numeric_limits<long long>,
    public detail::integer_traits_base<long long, LONGLONG_MIN, LONGLONG_MAX>
 { };
 template<>
 class integer_traits<unsigned long long>
  : public std::numeric_limits<unsigned long long>,
    public detail::integer_traits_base<unsigned long long, 0, ULONGLONG_MAX>
 { };
 #endif
@ -175,5 +186,3 @@ class integer_traits< detail::uxint_t >
 #endif /* BOOST_INTEGER_TRAITS_HPP */
--- a/index.html
+++ b/index.html
@ -7,11 +7,11 @@
 <body bgcolor="white" text="black">
 <table border="1" bgcolor="teal" cellpadding="2">
 	<tr>
-		<td bgcolor="white"><img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86"></td>
+		<td bgcolor="white"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
 		<td><a href="../../index.htm"><font face="Arial" color="white"><big>Home</big></font></a></td>
 		<td><a href="../libraries.htm"><font face="Arial" color="white"><big>Libraries</big></font></a></td>
-		<td><a href="http://www.boost.org/people/people.htm"><font face="Arial" color="white"><big>People</big></font></a></td>
+		<td><a href="../../people/people.htm"><font face="Arial" color="white"><big>People</big></font></a></td>
-		<td><a href="http://www.boost.org/more/faq.htm"><font face="Arial" color="white"><big>FAQ</big></font></a></td>
+		<td><a href="../../more/faq.htm"><font face="Arial" color="white"><big>FAQ</big></font></a></td>
 		<td><a href="../../more/index.htm"><font face="Arial" color="white"><big>More</big></font></a></td>
 	</tr>
 </table>
@ -121,13 +121,8 @@ instead.</p>
 <hr>
-<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->06 Nov 2007<!--webbot bot="Timestamp" endspan i-checksum="15272" -->
+<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->03 Oct 2001<!--webbot bot="Timestamp" endspan i-checksum="14373" -->
 </p>
 <p>© Copyright Beman Dawes 2003</p>
 <p>Distributed under the Boost Software License, Version 1.0. See
 <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
 </body>
-</html>
+</html>
--- a/integer.htm
+++ b/integer.htm
@ -6,7 +6,7 @@
 <body bgcolor="white" text="black">
 <h1>
-<img src="../../boost.png" alt="boost.png (6897 bytes)"
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
 align="middle" width="277" height="86">Integer Type Selection
 Templates</h1>
@ -21,9 +21,8 @@ is particularly useful for solving generic programming problems.</p>
 <ul>
 	<li><a href="#contents">Contents</a></li>
 	<li><a href="#synopsis">Synopsis</a></li>
-	<li><a href="#easy">Processor-Optimized Types</a></li>
+	<li><a href="#easy">Easiest-to-Manipulate Types</a></li>
 	<li><a href="#sized">Sized Types</a></li>
 	<li><a href="#mpl">MPL-Compatible Variants</a></li>
 	<li><a href="#example">Example</a></li>
 	<li><a href="#demo">Demonstration Program</a></li>
 	<li><a href="#rationale">Rationale</a></li>
@ -33,145 +32,67 @@ is particularly useful for solving generic programming problems.</p>
 <h2><a name="synopsis">Synopsis</a></h2>
-<blockquote><pre>
+<blockquote><pre>namespace boost
 #include &lt;<a href="../../boost/integer_fwd.hpp">boost/integer_fwd.hpp</a>&gt;  // forwarding header
 #include &lt;<a href="cstdint.htm">boost/cstdint.hpp</a>&gt;      // for boost::uintmax_t, intmax_t
 namespace boost
 {
  //  fast integers from least integers
  template&lt; typename BaseInt &gt;
  struct fast_integral
  {
      typedef <em>implementation_supplied</em>  type;
  };
  template&lt; typename LeastInt &gt;
  struct int_fast_t
  {
-      typedef typename fast_integral&lt;LeastInt&gt;::type  fast;
+      typedef <em>implementation_supplied</em>  fast;
  };
  //  MPL-compatible
  template&lt; int Bits, typename Signedness &gt;
  struct sized_integral
  {
      static  bool const  is_specialized = <em>implementation_supplied</em>;
      static  bool const  is_signed = <em>implementation_supplied</em>;
      static  int const   bit_count = Bits;
      typedef <em>implementation_supplied</em>  type;
  };
  template&lt; int Bits, typename Signedness &gt;
  struct exact_integral
  {
      static  bool const  is_specialized = <em>implementation_supplied</em>;
      static  bool const  is_signed = <em>implementation_supplied</em>;
      static  int const   bit_count = Bits;
      typedef <em>implementation_supplied</em>  type;
  };
  template&lt; intmax_t MaxValue &gt;
  struct maximum_signed_integral
  {
      static  bool const      is_specialized = <em>implementation_supplied</em>;
      static  bool const      is_signed = true;
      static  intmax_t const  bound = MaxValue;
      typedef <em>implementation_supplied</em>  type;
  };
  template&lt; intmax_t MinValue &gt;
  struct minimum_signed_integral
  {
      static  bool const      is_specialized = <em>implementation_supplied</em>;
      static  bool const      is_signed = true;
      static  intmax_t const  bound = MinValue;
      typedef <em>implementation_supplied</em>  type;
  };
  template&lt; uintmax_t Value &gt;
  struct maximum_unsigned_integral
  {
      static  bool const       is_specialized = <em>implementation_supplied</em>;
      static  bool const       is_signed = false;
      static  uintmax_t const  bound = Value;
      typedef <em>implementation_supplied</em>  type;
  };
  //  signed
  template&lt; int Bits &gt;
  struct int_t 
  {
-      typedef typename sized_integral&lt;Bits, signed&gt;::type  least;
+      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast                      fast;
+      typedef int_fast_t&lt;least&gt;::fast  fast;
  };
  template&lt; int Bits &gt;
  struct int_exact_t
  {
      typedef typename exact_integral&lt;Bits, signed&gt;::type  exact;
  };
  //  unsigned
  template&lt; int Bits &gt;
  struct uint_t 
  {
-      typedef typename sized_integral&lt;Bits, unsigned&gt;::type  least;
+      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast                        fast;
+      typedef int_fast_t&lt;least&gt;::fast  fast;
  };
  template&lt; int Bits &gt;
  struct uint_exact_t
  {
      typedef typename exact_integral&lt;Bits, unsigned&gt;::type  exact;
  };
  //  signed
-  template&lt; intmax_t MaxValue &gt;
+  template&lt; long MaxValue &gt;
  struct int_max_value_t 
  {
-      typedef typename maximum_signed_integral&lt;MaxValue&gt;::type  least;
+      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast                           fast;
+      typedef int_fast_t&lt;least&gt;::fast  fast;
  };
-  template&lt; intmax_t MinValue &gt;
+  template&lt; long MinValue &gt;
  struct int_min_value_t 
  {
-      typedef typename minimum_signed_integral&lt;MinValue&gt;::type  least;
+      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast                           fast;
+      typedef int_fast_t&lt;least&gt;::fast  fast;
  };
  //  unsigned
-  template&lt; uintmax_t Value &gt;
+  template&lt; unsigned long Value &gt;
  struct uint_value_t 
  {
-      typedef typename maximum_unsigned_integral&lt;Value&gt;::type  least;
+      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast                          fast;
+      typedef int_fast_t&lt;least&gt;::fast  fast;
  };
 } // namespace boost
 </pre></blockquote>
-<h2><a name="easy">Processor-Optimized Types</a></h2>
+<h2><a name="easy">Easiest-to-Manipulate Types</a></h2>
-<p>The <code>fast_integral</code> class template maps its input type to the
+<p>The <code>int_fast_t</code> 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 <code>char</code> objects may go faster
 if they were converted to <code>int</code> objects before processing. 
-The input type, passed as the only template parameter, can be any built-in
+The input type, passed as the only template parameter, must be a
-integral type besides <code>bool</code>.  The output type is given as the class
+built-in integral type, except <code>bool</code>.  Unsigned integral
-member <code>type</code>.</p>
+types can be used, as well as signed integral types, despite the name. 
-
+The output type is given as the class member <code>fast</code>.</p>
 <p>The <code>int_fast_t</code> 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 <code>fast</code>, defined to be the same as the corresponding
 result from the <code>fast_integral</code> meta-function.</p>
 <p><strong>Implementation Notes</strong><br>
 By default, the output type is identical to the input type.  Eventually,
@ -183,286 +104,72 @@ type.</p>
 <h2><a name="sized">Sized Types</a></h2>
-<p>The <code>int_t</code>, <code>int_exact_t</code>, <code>uint_t</code>,
+<p>The <code>int_t</code>, <code>uint_t</code>,
-<code>uint_exact_t</code>, <code>int_max_value_t</code>,
+<code>int_max_value_t</code>, <code>int_min_value_t</code>, and
-<code>int_min_value_t</code>, and <code>uint_value_t</code> class templates find
+<code>uint_value_t</code> class templates find the most appropiate
-the most appropriate built-in integral type for the given template parameter.
+built-in integral type for the given template parameter.  This type is
-This type is given by the class member <code>least</code> or <code>exact</code>.
+given by the class member <code>least</code>.  The easiest-to-manipulate
-For the non-exact class templates, the easiest-to-manipulate version of that
+version of that type is given by the class member <code>fast</code>. 
-type is given by the class member <code>fast</code>.  The following table
+The following table describes each template's criteria.</p>
 describes each template's criteria.</p>
-<table border="2" cellpadding="5">
+<table border="1" cellpadding="5">
 	<caption>Criteria for the Sized Type Class Templates</caption>
 	<tr>
-		<th>Class Template (all in name-space <code>boost</code>)</th>
+		<th>Class Template</th>
 		<th>Template Parameter Mapping</th>
 	</tr>
 	<tr>
-		<td><code>int_t</code></td>
+		<td><code>boost::int_t</code></td>
 		<td>The smallest built-in signed integral type with at least the
 			given number of bits, including the sign bit.  The parameter
-			<em>must</em> 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
-			<code>boost::intmax_t</code>.</td>
+			<code>long</code>.</td>
 	</tr>
 	<tr>
-		<td><code>int_exact_t</code></td>
+		<td><code>boost::uint_t</code></td>
 		<td>The 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.</td>
 	</tr>
 	<tr>
 		<td><code>uint_t</code></td>
 		<td>The smallest built-in unsigned integral type with at least
-			the given number of bits.  The parameter <em>must</em> be a
+			the given number of bits.  The parameter should be a positive
-			non-negative number.  A compile-time error results if the parameter
+			number.  A compile-time error results if the parameter is
-			is larger than the number of bits in a
+			larger than the number of bits in an <code>unsigned
-			<code>boost::uintmax_t</code>.</td>
+			long</code>.</td>
 	</tr>
 	<tr>
-		<td><code>uint_exact_t</code></td>
+		<td><code>boost::int_max_value_t</code></td>
 		<td>The smallest built-in unsigned integral type with exactly the given
 			number of bits.  A compile-time error results if no qualifying type
 			exists.</td>
 	</tr>
 	<tr>
 		<td><code>int_max_value_t</code></td>
 		<td>The smallest built-in signed integral type that supports the
-			given value as a maximum.  The parameter <em>must</em> be a
+			given value as a maximum.  The parameter should be a
 			positive number.</td>
 	</tr>
 	<tr>
-		<td><code>int_min_value_t</code></td>
+		<td><code>boost::int_min_value_t</code></td>
 		<td>The smallest built-in signed integral type that supports the
-			given value as a minimum.  The parameter <em>must</em> be a
+			given value as a minimum.  The parameter should be a
 			negative number.</td>
 	</tr>
 	<tr>
-		<td><code>uint_value_t</code></td>
+		<td><code>boost::uint_value_t</code></td>
 		<td>The smallest built-in unsigned integral type that supports
 			the given value as a maximum.  The parameter should be a
 			positive number.</td>
 	</tr>
 </table>
 <h2><a name="mpl">MPL-Compatible Variants</a></h2>
 <p>The bit-length sized-type class templates have several drawbacks:</p>
 <ul>
 	<li>You must know the valid bit-lengths in advance.</li>
 	<li>There is no way to inspect the parameter used after a size-type template
 	    class is aliased.</li>
 	<li>Using an inappropriate parameter value results in a compiler
 	    diagnostic.</li>
 	<li>The type names used are inconsistent with other transformations in
 	    Boost, like in <a href="../mpl/">MPL</a>.</li>
 	<li>The above two facts make use of the size-type class templates
 	    incompatible with template meta-programming techniques.</li>
 </ul>
 <p>The <code>sized_integral</code>, <code>exact_integral</code>,
 <code>maximum_signed_integral</code>, <code>minimum_signed_integral</code>, and
 <code>maximum_unsigned_integral</code> class templates provide MPL-compatible
 alternatives.  These alternatives generally have the form:</p>
 <blockquote><pre>
 template&lt; <var>SwitchType</var> <var>SwitchValue</var>, typename Signedness &gt;
 struct <var>name</var>
 {
    static  bool const         is_specialized = <em>implementation_supplied</em>;
    static  bool const         is_signed = <em>implementation_supplied</em>;
    static  <var>SwitchType</var> const   <var>switch_id</var> = <var>SwitchValue</var>;
    typedef <em>implementation_supplied</em>  type;
 };
 </pre></blockquote>
 <p>Each member, if present, is defined by:</p>
 <table border="2" cellpadding="5">
 	<caption>Members in MPL-Compatible Class Templates</caption>
 	<tr>
 		<th>Class Template Member</th>
 		<th>When Defined</th>
 		<th>Meaning</th>
 	</tr>
 	<tr>
 		<td><code>is_specialized</code></td>
 		<td>Always</td>
 		<td>Flag indicating when a particular template class instantiation is a
 		    valid meta-function (<code>true</code>) or not (<code>false</code>).</td>
 	</tr>
 	<tr>
 		<td><code>is_signed</code></td>
 		<td><code>is_specialized == true</code></td>
 		<td>Flag indicating whether the signed-variant (<code>true</code>) or
 		    the unsigned-variant (<code>false</code>) of the meta-function is
 		    used.  This is controlled by the <code>Signedness</code> template
 		    parameter:
 		    <table border="1" cellpadding="3" align="center">
 		    	<caption>Effect of <code>Signedness</code> Setting</caption>
 		    	<tr>
 		    		<th><code>Signedness</code> Type</th>
 		    		<th><code>is_signed</code></th>
 		    	</tr>
 		    	<tr>
 		    		<td><code>signed</code></td>
 		    		<td><code>true</code></td>
 		    	</tr>
 		    	<tr>
 		    		<td><code>unsigned</code></td>
 		    		<td><code>false</code></td>
 		    	</tr>
 		    	<tr>
 		    		<td>anything else</td>
 		    		<td><em>not defined</em></td>
 		    	</tr>
 		    </table>
 		    The type used is a programmer mnemonic; the compiler cannot prevent
 		    someone from using <code>int</code> or <code>signed int</code>
 		    instead of <code>signed</code>, or <code>unsigned int</code> instead
 		    of <code>unsigned</code>.</td>
 	</tr>
 	<tr>
 		<td><code><var>switch_id</var></code> (Actual name is template-specific.)</td>
 		<td>Always</td>
 		<td>The value of the main control parameter, accessible even if the
 			template class instantiation is aliased.</td>
 	</tr>
 	<tr>
 		<td><code>type</code></td>
 		<td><code>is_specialized == true</code></td>
 		<td>The meta-function's result.  It appears only if the input parameters
 			satisfy the template's requirements.  Its presence, or lack thereof,
 			enables &quot;Substitution Failure Is Not An Error&quot; (SFINAE)
 			techniques, instead of a hard compiler diagnostic.</td>
 	</tr>
 </table>
 <p>The exceptions are the extreme-value class templates
 (<code>maximum_signed_integral</code>, <code>minimum_signed_integral</code>, and
 <code>maximum_unsigned_integral</code>), which do not take a <var>Signedness</var>
 template parameter because the meta-functions already inherently have signedness.
 <p>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 <var>Signedness</var>
 controls the appropriate emulation.)</p>
 <table border="2" cellpadding="5">
 	<caption>Criteria for the MPL-Compatible Class Templates</caption>
 	<tr>
 		<th rowspan="2">Class Template (all in name-space <code>boost</code>)</th>
 		<th rowspan="2">Parameter Type (in name-space <code>boost</code> as needed)</th>
 		<th rowspan="2">Parameter Member ID</th>
 		<th colspan="2">Classic Equivalent</th>
 		<th rowspan="2" colspan="2">Template Parameter Mapping (when <code>type</code> is defined)</th>
 	</tr>
 	<tr>
 		<th>Signed</th>
 		<th>Unsigned</th>
 	</tr>
 	<tr>
 		<td><code>sized_integral</code></td>
 		<td><code>int</code></td>
 		<td><code>bit_count</code></td>
 		<td><code>int_t</code></td>
 		<td><code>uint_t</code></td>
 		<td colspan="2">The smallest built-in integral type with at least
 			<code>bit_count</code> bits (including the sign bit when
 			<var>Signedness</var> is <code>signed</code>).  Not present if no
 			type qualifies.</td>
 	</tr>
 	<tr>
 		<td><code>exact_integral</code></td>
 		<td><code>int</code></td>
 		<td><code>bit_count</code></td>
 		<td><code>int_exact_t</code></td>
 		<td><code>uint_exact_t</code></td>
 		<td colspan="2">The smallest built-in integral type with exactly
 			<code>bit_count</code> bits (including the sign bit when
 			<var>Signedness</var> is <code>signed</code>).  Not present if no
 			type qualifies.</td>
 	</tr>
 	<tr>
 		<td><code>maximum_signed_integral</code></td>
 		<td><code>intmax_t</code></td>
 		<td><code>bound</code></td>
 		<td colspan="2"><code>int_max_value_t</code></td>
 		<td>The smallest built-in integral type that can perserve the value in
 			<code>bound</code>.  Not present if <code>bound</code> is non-positive.</td>
 		<td rowspan="3">It is possible for a <code>type</code> to be absent if
 			a platform supports really-extended integral types (beyond <code>long
 			long</code> or <code>__int64</code>), support for those types goes
 			into &lt;<a href="../../boost/cstdint.hpp">boost/cstdint.hpp</a>&gt;,
 			but said support hadn't yet been added to &lt;<a
 			href="../../boost/integer.hpp">boost/integer.hpp</a>&gt;</td>
 	</tr>
 	<tr>
 		<td><code>minimum_signed_integral</code></td>
 		<td><code>intmax_t</code></td>
 		<td><code>bound</code></td>
 		<td colspan="2"><code>int_min_value_t</code></td>
 		<td>The smallest built-in integral type that can perserve the value in
 			<code>bound</code>.  Not present if <code>bound</code> is non-negative.</td>
 	</tr>
 	<tr>
 		<td><code>maximum_unsigned_integral</code></td>
 		<td><code>uintmax_t</code></td>
 		<td><code>bound</code></td>
 		<td colspan="2"><code>uint_value_t</code></td>
 		<td>The smallest built-in integral type that can perserve the value in
 			<code>bound</code>.  Should always be present.</td>
 	</tr>
 </table>
 <h2><a name="example">Example</a></h2>
-<blockquote><pre>
+<blockquote><pre>#include &lt;boost/integer.hpp&gt;
 #include &lt;<a href="../../boost/integer.hpp">boost/integer.hpp</a>&gt;
 #include &lt;<a href="../../boost/mpl/int.hpp">boost/mpl/int.hpp</a>&gt;
 #include &lt;iostream&gt;
 #include &lt;ostream&gt;
 //...
 template &lt; int Bits &gt;
 bool
 fit_exactly( boost::mpl::int_&lt;Bits&gt; const &amp;x,
 typename boost::exact_integral&lt;Bits, signed&gt;::type *unused = 0 )
 {
    return true;
 }
 template &lt; typename T &gt;
 bool
 fit_exactly( T const &amp;x )
 {
    return false;
 }
 //...
 int main()
 {
-    typedef boost::mpl::int_&lt;24&gt;  twenty_four;
+    boost::int_t&lt;24&gt;::least my_var;
    boost::int_t&lt;twenty_four::value&gt;::least my_var;
    //...
    std::cout &lt;&lt; &quot;my_var &quot; &lt;&lt; ( fit_exactly(twenty_four()) ? &quot;does&quot; :
     &quot;does not&quot; ) &lt;&lt; &quot; fit its type exactly.&quot; &lt;&lt; std::endl;
    //...
 }
 </pre></blockquote>
 <h2><a name="demo">Demonstration Program</a></h2>
-<p>The program <a href="test/integer_test.cpp">integer_test.cpp</a> is a
+<p>The program <a href="integer_test.cpp">integer_test.cpp</a> is a
 simplistic demonstration of the results from instantiating various
 examples of the sized type class templates.</p>
@ -486,20 +193,21 @@ href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;</a></cite>.</p>
 <h2><a name="credits">Credits</a></h2>
 <p>The author of most of the Boost integer type choosing templates is <a
-href="http://www.boost.org/people/beman_dawes.html">Beman Dawes</a>.  He gives thanks
+href="../../people/beman_dawes.html">Beman Dawes</a>.  He gives thanks
 to Valentin Bonnard and
-<a href="http://www.boost.org/people/kevlin_henney.htm"> Kevlin Henney</a> for sharing
+<a href="../../people/kevlin_henney.htm"> Kevlin Henney</a> for sharing
 their designs for similar templates.  <a
-href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a> designed the
+href="../../people/daryle_walker.html">Daryle Walker</a> designed the
-exact and value-based sized templates, and the MPL-compatible templates.</p>
+value-based sized templates.</p>
 <hr>
-<p>Revised July 16, 2008</p>
+<p>Revised May 20, 2001</p>
-<p>&copy; Copyright Beman Dawes 1999.  Use, modification, and distribution are
+<p>&copy; Copyright Beman Dawes 1999.  Permission to copy, use, modify,
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
+sell and distribute this document is granted provided this copyright
-href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
+notice appears in all copies.  This document is provided &quot;as
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+is&quot; without express or implied warranty, and with no claim as to
 its suitability for any purpose.</p>
 </body>
-</html>
+</html>
--- a/integer_test.cpp
+++ b/integer_test.cpp
@ -0,0 +1,255 @@
 //  boost integer.hpp test program  ------------------------------------------//
 //  (C) Copyright Beman Dawes 1999. Permission to copy, use, modify, sell
 //  and distribute this software is granted provided this copyright
 //  notice appears in all copies. This software is provided "as is" without
 //  express or implied warranty, and with no claim as to its suitability for
 //  any purpose.
 //  See http://www.boost.org for most recent version including documentation.
 //  Revision History
 //   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_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>  // for main, BOOST_TEST
 #include <boost/config.hpp>   // for BOOST_NO_USING_TEMPLATE
 #include <boost/cstdlib.hpp>  // for boost::exit_success
 #include <boost/integer.hpp>  // for boost::int_t, boost::uint_t
 #include <climits>   // for ULONG_MAX, LONG_MAX, LONG_MIN
 #include <iostream>  // for std::cout (std::endl indirectly)
 #include <typeinfo>  // for std::type_info
 // 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.
 namespace boost
 {
    template < >
    struct int_fast_t< short >
    {
        typedef long  fast;
    };
 }
 // 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
 #define SHOW_TYPE(Template, Number, Type)
 #endif
 #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_TEST( Template < Number > :: Type ( Value ) == Value )
 #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 )
 #define PRIVATE_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( 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_TEST( 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_TEST( 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
    using namespace boost;
 #endif
    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;
 }
--- a/integer_traits.html
+++ b/integer_traits.html
@ -8,7 +8,7 @@
 <body bgcolor="#FFFFFF" text="#000000">
-<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" width="277" height="86">Compile-Time Integral
+<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Compile-Time Integral
 Type Limits</h1>
 <p>
@ -77,7 +77,7 @@ Test Program</h2>
 <p>
-The program <code><a href="test/integer_traits_test.cpp">integer_traits_test.cpp</a></code>
+The program <code><a href="integer_traits_test.cpp">integer_traits_test.cpp</a></code>
 exercises the <code>integer_traits</code> class.
 <h2>Acknowledgements</h2>
@ -85,10 +85,5 @@ exercises the <code>integer_traits</code> class.
 Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer
 traits idea on the boost mailing list in August 1999.
 <hr>
-<p>Revised
+<a href="../../people/jens_maurer.htm">
-<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->06 November 2007<!--webbot bot="Timestamp" endspan i-checksum="40336" --></p>
+Jens Maurer</a>, 2000-02-20
 <p><EFBFBD> Copyright Beman Dawes 2000</p>
 <p>Distributed under the Boost Software License, Version 1.0. See
 <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
--- a/test/integer_traits_test.cpp
+++ b/test/integer_traits_test.cpp
@ -1,9 +1,14 @@
 /* boost integer_traits.hpp tests
 *
 * Copyright Jens Maurer 2000
- * Distributed under the Boost Software License, Version 1.0. (See
+ * Permission to use, copy, modify, sell, and distribute this software
- * accompanying file LICENSE_1_0.txt or copy at
+ * is hereby granted without fee provided that the above copyright notice
- * http://www.boost.org/LICENSE_1_0.txt)
+ * appears in all copies and that both that copyright notice and this
 * permission notice appear in supporting documentation,
 *
 * Jens Maurer makes no representations about the suitability of this
 * software for any purpose. It is provided "as is" without express or
 * implied warranty.
 *
 * $Id$
 *
@ -50,22 +55,14 @@ void runtest(const char * type, T)
 {
  typedef boost::integer_traits<T> traits;
  std::cout << "Checking " << type
-            << "; min is " << make_char_numeric_for_streaming((traits::min)())
+            << "; min is " << make_char_numeric_for_streaming(traits::min())
-            << ", max is " << make_char_numeric_for_streaming((traits::max)())
+            << ", max is " << make_char_numeric_for_streaming(traits::max())
            << std::endl;
-  BOOST_CHECK(traits::is_specialized);
+  BOOST_TEST(traits::is_specialized);
-#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
+  BOOST_TEST(traits::is_integer);
-  // MSVC++ 6.0 issues a LNK1179 error (duplicate comdat) when the compiler
+  BOOST_TEST(traits::is_integral);
-  // generates different symbol names with a very long common prefix:
+  BOOST_TEST(traits::const_min == traits::min());
-  // the dummy "&& true" disambiguates between the symbols generated by this
+  BOOST_TEST(traits::const_max == traits::max());
  // BOOST_CHECK instantiation and the preceding one.
  BOOST_CHECK(traits::is_integer && true);
 #else
  BOOST_CHECK(traits::is_integer);
 #endif
  BOOST_CHECK(traits::is_integral == true);
  BOOST_CHECK(traits::const_min == (traits::min)());
  BOOST_CHECK(traits::const_max == (traits::max)());
 }
 int test_main(int, char*[])
--- a/module.cmake
+++ b/module.cmake
@ -1 +0,0 @@
 boost_module(integer DEPENDS utility)
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -1,9 +0,0 @@
 boost_additional_test_dependencies(integer BOOST_DEPENDS test) 
 boost_test_run(cstdint_test cstdint_test.cpp)
 boost_test_run(integer_mask_test integer_mask_test.cpp DEPENDS boost_test_exec_monitor)
 boost_test_run(integer_test integer_test.cpp DEPENDS boost_test_exec_monitor)
 boost_test_run(integer_traits_test integer_traits_test.cpp DEPENDS boost_test_exec_monitor)
 boost_test_run(issue_2134 issue_2134.cpp)
 boost_test_run(static_log2_test static_log2_test.cpp DEPENDS boost_test_exec_monitor)
 boost_test_run(static_min_max_test static_min_max_test.cpp DEPENDS boost_test_exec_monitor)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -1,20 +0,0 @@
 #~ Copyright Rene Rivera 2008
 #~ Distributed under the Boost Software License, Version 1.0.
 #~ (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 import testing ;
 test-suite integer
    :   [ run cstdint_test.cpp ]
        [ run integer_test.cpp
            /boost/test//boost_unit_test_framework ]
        [ run integer_traits_test.cpp
            /boost/test//boost_test_exec_monitor/<link>static ]
        [ run integer_mask_test.cpp
            /boost/test//boost_unit_test_framework ]
        [ run static_log2_test.cpp
            /boost/test//boost_test_exec_monitor/<link>static ]
        [ run static_min_max_test.cpp
            /boost/test//boost_test_exec_monitor/<link>static ]
        [ compile issue_2134.cpp ]
    ;
--- a/test/integer_mask_test.cpp
+++ b/test/integer_mask_test.cpp
@ -1,156 +1,112 @@
 //  boost integer_mask.hpp test program  -------------------------------------//
-//  (C) Copyright Daryle Walker 2001.
+//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  and distribute this software is granted provided this copyright
-//  accompanying file LICENSE_1_0.txt or copy at
+//  notice appears in all copies.  This software is provided "as is" without
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  express or implied warranty, and with no claim as to its suitability for
 //  any purpose.
 //  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"
+#define  BOOST_INCLUDE_MAIN
-#include <boost/test/unit_test.hpp>  // unit testing framework
+#include <boost/test/test_tools.hpp>  // for main
-#include <boost/cstdint.hpp>               // for boost::uintmax_t
+#include <boost/cstdlib.hpp>               // for boost::exit_success
 #include <boost/integer/integer_mask.hpp>  // for boost::high_bit_mask_t, etc.
 #include <boost/limits.hpp>                // for std::numeric_limits
 #include <boost/mpl/assert.hpp>            // for BOOST_MPL_ASSERT_RELATION,etc.
 #include <boost/mpl/bool.hpp>              // for boost::mpl::bool_
 #include <boost/mpl/bitwise.hpp>           // for boost::mpl::bitor_, shift_left
 #include <boost/mpl/equal_to.hpp>          // for boost::mpl::equal_to
 #include <boost/mpl/int.hpp>               // for boost::mpl::int_
 #include <boost/mpl/integral_c.hpp>        // for boost::mpl::integral_c
 #include <boost/mpl/next_prior.hpp>        // for boost::mpl::prior
 #include <boost/mpl/range_c.hpp>           // for boost::mpl::range_c
-#include <cstddef>   // for std::size_t
+#include <iostream>  // for std::cout (std::endl indirectly)
 #include <ios>       // for std::hex
-// Custom types/templates, helper functions, and objects
+#define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
-namespace
+ (v) >::high_bit == (1ul << (v)) );
 #define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_TEST( ::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_TEST( ::boost::low_bits_mask_t< \
 (v) >::sig_bits == ((1ul << (v)) - 1) );
 #define PRIVATE_LOW_BITS_FAST_TEST(v)  BOOST_TEST( ::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)
+    cout << "Doing high_bit_mask_t tests." << endl;
-int const  max_offset = std::numeric_limits<boost::uintmax_t>::digits;
+    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<int, 0, max_offset>             high_bit_offsets;
+    cout << "Doing low_bits_mask_t tests." << endl;
-typedef boost::mpl::range_c<int, 0, max_offset + 1>          low_bit_lengths;
+    PRIVATE_LOW_BITS_TEST( 32 );  // Undefined behavior?  Whoops!
-typedef boost::mpl::range_c<int, 1, max_offset + 1>  special_low_bit_lengths;
+    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
+    return boost::exit_success;
 typedef boost::mpl::range_c<int, -10, max_offset + 11>  wild_bit_lengths;
 // Use SFINAE to check if a particular parameter is supported
 template < typename ValueT, template<ValueT> class Tmpl, ValueT Value >
 bool
 print_out_template( Tmpl<Value> const &, ValueT setting, char const
 *template_name, typename Tmpl<Value>::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>::value_type).name() << "' and value '" << std::hex <<
     Tmpl<Value>::value << "'." );
    return true;
 }
 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<typename
     boost::high_bit_mask_t<T::value>::least, 1u>   one_type;
    typedef boost::mpl::shift_left<one_type, T>  result_type;
    BOOST_MPL_ASSERT_RELATION( boost::high_bit_mask_t<T::value>::high_bit, ==,
     result_type::value );
    BOOST_MPL_ASSERT_RELATION( boost::high_bit_mask_t<T::value>::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<T>::type                  shift_type;
    typedef boost::mpl::integral_c<typename
     boost::low_bits_mask_t<T::value>::least, 1u>                  one_type;
    typedef boost::mpl::shift_left<one_type, shift_type>      high_bit_type;
    typedef typename boost::mpl::prior<high_bit_type>::type   low_bits_type;
    typedef boost::mpl::bitor_<high_bit_type, low_bits_type>    result_type;
    BOOST_MPL_ASSERT_RELATION( boost::low_bits_mask_t<T::value>::sig_bits, ==,
     result_type::value );
    BOOST_MPL_ASSERT_RELATION( boost::low_bits_mask_t<T::value>::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<T::value>                    hi_type;
    typedef boost::mpl::int_<hi_type::bit_offset>        hi_offset_type;
    typedef boost::mpl::bool_<hi_type::is_specialized>  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<T::value>                    lo_type;
    typedef boost::mpl::int_<lo_type::bit_count>         lo_length_type;
    typedef boost::mpl::bool_<lo_type::is_specialized>  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()
--- a/test/integer_test.cpp
+++ b/test/integer_test.cpp
@ -1,669 +0,0 @@
 //  boost integer.hpp test program  ------------------------------------------//
 //  Copyright Beman Dawes 1999.  Distributed under the Boost
 //  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 <boost/test/unit_test.hpp>  // unit testing framework
 #include <boost/config.hpp>          // for BOOST_NO_SFINAE
 #include <boost/cstdint.hpp>         // for boost::uintmax_t, intmax_t
 #include <boost/integer.hpp>         // for boost::int_t, boost::uint_t, etc.
 #include <boost/integer_traits.hpp>  // for boost::integer_traits
 #include <boost/limits.hpp>          // for std::numeric_limits
 #include <boost/detail/extended_integer.hpp>  // BOOST_HAS_XINT, BOOST_UXINT_MAX
 #include <boost/mpl/arithmetic.hpp>      // for boost::mpl::plus, divides
 #include <boost/mpl/assert.hpp>          // for BOOST_MPL_ASSERT_RELATION, etc.
 #include <boost/mpl/back.hpp>            // for boost::mpl::back
 #include <boost/mpl/copy.hpp>            // for boost::mpl::copy
 #include <boost/mpl/equal.hpp>           // for boost::mpl::equal
 #include <boost/mpl/front_inserter.hpp>  // for boost::mpl::front_inserter
 #include <boost/mpl/int.hpp>             // for boost::mpl::int_
 #include <boost/mpl/integral_c.hpp>      // for boost::mpl::integral_c
 #include <boost/mpl/joint_view.hpp>      // for boost::mpl::joint_view
 #include <boost/mpl/pop_back.hpp>        // for boost::mpl::pop_back
 #include <boost/mpl/push_back.hpp>       // for boost::mpl::push_back 
 #include <boost/mpl/push_front.hpp>      // for boost::mpl::push_front
 #include <boost/mpl/range_c.hpp>         // for boost::mpl::range_c
 #include <boost/mpl/shift_right.hpp>     // for boost::mpl::shift_right
 #include <boost/mpl/sort.hpp>            // for boost::mpl::sort
 #include <boost/mpl/transform.hpp>       // for boost::mpl::transform
 #include <boost/mpl/transform_view.hpp>  // for boost::mpl::transform_view
 #include <boost/mpl/unpack_args.hpp>     // for boost::mpl::unpack_args
 #include <boost/mpl/vector.hpp>          // for boost::mpl::vector
 #include <boost/mpl/zip_view.hpp>        // for boost::mpl::zip_view
 #include <boost/type_traits/is_same.hpp>      // for boost::is_same
 #include <boost/type_traits/make_signed.hpp>  // for boost::make_signed
 #include <algorithm>  // for std::binary_search
 #include <climits>    // for ULONG_MAX, LONG_MAX, LONG_MIN, etc.
 #include <cstddef>    // for std::size_t
 #include <typeinfo>   // 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
 #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.
 namespace boost
 {
    template < >
    struct fast_integral< short >
    {
        typedef CONTROL_FAST_SHORT  type;
    };
 }
 // 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<T>::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<boost:: intmax_t>   intmax_limits;
 typedef std::numeric_limits<boost::uintmax_t>  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<int, 0, uintmax_bits + 2>  bits_list;
 #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<int, uintmax_bits + 1>
            >
        >
    >::type
 >::type  bits_list;
 #endif
 // Remove the outlier when all bits counts must be valid
 #if CONTROL_FULL_COUNTS
 typedef boost::mpl::range_c<int, 0, uintmax_bits + 1>  valid_bits_list;
 #else
 typedef boost::mpl::pop_back<bits_list>::type  valid_bits_list;
 #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<int, 1, uintmax_bits + 1>
  valid_to_decrease_bits_list;
 #else
 typedef valid_bits_list  valid_to_decrease_bits_list;
 #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<int, 0, uintmax_bits>  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<int, 0, intmax_bits - 2>
  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<Bits, signed>  {};
 template < int Bits >
 struct unsigned_sized_integral  : boost::sized_integral<Bits, unsigned>  {};
 template < int Bits >
 struct signed_exact_integral  : boost::exact_integral<Bits, signed>  {};
 template < int Bits >
 struct unsigned_exact_integral  : boost::exact_integral<Bits, unsigned>  {};
 // Use SFINAE to check if a particular parameter is supported
 #ifndef BOOST_NO_SFINAE
 template < typename ValueT, template<ValueT> class Tmpl, ValueT Value >
 bool
 print_out_template( Tmpl<Value> const &, ValueT setting, char const
 *template_pre_name, char const *template_post_name, typename Tmpl<Value>::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<Value>::type).name() << "'." );
    return true;
 }
 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<T>::const_min >
 {
 };
 template < typename T >
 struct maximum_of
    : boost::mpl::integral_c< T, boost::integer_traits<T>::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<least_type>::fast  fast_type;
    typedef std::numeric_limits<least_type>     least_limits;
    typedef std::numeric_limits<fast_type>       fast_limits;
    typedef boost::fast_integral<least_type>::type  real_fast_type;
    BOOST_MPL_ASSERT_RELATION( (boost::is_same<least_type, fast_type>::value),
     ==, false );
    BOOST_MPL_ASSERT_RELATION( (boost::is_same<fast_type,
     real_fast_type>::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>(),
     T::value, "a sized_integral<", ", signed>"), T::value && (T::value <=
     intmax_bits) );
    BOOST_CHECK_EQUAL( print_out_template(unsigned_sized_integral<T::value>(),
     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<N>::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<typename
     boost::uint_t<T::value>::least>::digits, >=, T::value );
    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
     boost::uint_t<T::value>::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<typename
     boost::int_t<T::value>::least>::digits, >=, T::value - 1 );
    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
     boost::int_t<T::value>::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<T::value + 1> >) );
 }
 // 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<T::value + 1> >) );
    BOOST_MPL_ASSERT( (boost::mpl::equal< boost::minimum_signed_integral<-(one
     << T::value)>, signed_sized_integral<T::value + 1> >) );
 }
 // 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>(),
     T::value, "an exact_integral<", ", signed>"), is_exact_length );
    BOOST_CHECK_EQUAL( print_out_template(unsigned_exact_integral<T::value>(),
     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<typename
     boost::int_exact_t<T::value>::exact>::digits, ==, T::value - 1 );
    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
     boost::uint_exact_t<T::value>::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<typename Template<N>::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<typename
     unsigned_sized_integral<count>::type>(value_u), value_u );
    BOOST_CHECK_EQUAL( static_cast<typename
     boost::uint_t<count>::least>(value_u), value_u );
    BOOST_CHECK_EQUAL( static_cast<typename
     boost::uint_t<count>::fast>(value_u), value_u );
    BOOST_CHECK_EQUAL( static_cast<typename
     signed_sized_integral<count>::type>(value_s), value_s );
    BOOST_CHECK_EQUAL( static_cast<typename
     boost::int_t<count>::least>(value_s), value_s );
    BOOST_CHECK_EQUAL( static_cast<typename
     boost::int_t<count>::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<T::value, unsigned>::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<T::value, signed>::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<typename Template<V>::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<maximum_of<uintmax_t>, T>  maxi_type;
    uintmax_t const  maxi = maxi_type::value;
    BOOST_CHECK_EQUAL( static_cast<typename
     boost::uint_value_t<maxi_type::value>::least>(maxi), maxi );
    BOOST_CHECK_EQUAL( static_cast<typename
     boost::uint_value_t<maxi_type::value>::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<typename Template<V>::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<minimum_of<intmax_t>, T>  mini_type;
    typedef boost::mpl::shift_right<maximum_of<intmax_t>, T>  maxi_type;
    intmax_t const  maxi = maxi_type::value, mini = mini_type::value;
    BOOST_CHECK_EQUAL( static_cast<typename
     boost::int_max_value_t<maxi_type::value>::least>(maxi), maxi );
    BOOST_CHECK_EQUAL( static_cast<typename
     boost::int_max_value_t<maxi_type::value>::fast>(maxi), maxi );
    BOOST_CHECK_EQUAL( static_cast<typename
     boost::int_min_value_t<mini_type::value>::least>(mini), mini );
    BOOST_CHECK_EQUAL( static_cast<typename
     boost::int_min_value_t<mini_type::value>::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()
--- a/test/issue_2134.cpp
+++ b/test/issue_2134.cpp
@ -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 <http://www.boost.org/LICENSE_1_0.txt>.)
 //  See <http://www.boost.org/libs/integer> for documentation.
 //  See <http://svn.boost.org/trac/boost/ticket/2134> 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 <boost/detail/numeric_traits.hpp>
 #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, <boost/detail/numeric_traits.hpp>
 // 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 <boost/integer.hpp>
 // Main program, minimal (since this is a compile test)
 int  main()  { return 0; }
--- a/test/static_log2_test.cpp
+++ b/test/static_log2_test.cpp
@ -1,9 +1,10 @@
 //  Boost static_log2.hpp test program  --------------------------------------//
-//  (C) Copyright Daryle Walker 2001.
+//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  and distribute this software is granted provided this copyright
-//  accompanying file LICENSE_1_0.txt or copy at
+//  notice appears in all copies.  This software is provided "as is" without
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  express or implied warranty, and with no claim as to its suitability for
 //  any purpose.
 //  See http://www.boost.org for most recent version including documentation.
@ -20,7 +21,7 @@
 // Macros to compact code
-#define PRIVATE_LB_TEST( v, e )  BOOST_CHECK( ::boost::static_log2<v>::value == e )
+#define PRIVATE_LB_TEST( v, e )  BOOST_TEST( ::boost::static_log2<v>::value == e )
 #define PRIVATE_PRINT_LB( v )    ::std::cout << "boost::static_log2<" << (v) \
 << "> = " << ::boost::static_log2< (v) >::value << '.' << ::std::endl
--- a/test/static_min_max_test.cpp
+++ b/test/static_min_max_test.cpp
@ -1,9 +1,10 @@
 //  Boost static_min_max.hpp test program  -----------------------------------//
-//  (C) Copyright Daryle Walker 2001.
+//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell
-//  Distributed under the Boost Software License, Version 1.0. (See
+//  and distribute this software is granted provided this copyright
-//  accompanying file LICENSE_1_0.txt or copy at
+//  notice appears in all copies.  This software is provided "as is" without
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  express or implied warranty, and with no claim as to its suitability for
 //  any purpose.
 //  See http://www.boost.org for most recent version including documentation.
@ -11,7 +12,7 @@
 //  23 Sep 2001  Initial version (Daryle Walker)
 #define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main, BOOST_CHECK
+#include <boost/test/test_tools.hpp>  // for main, BOOST_TEST
 #include <boost/cstdlib.hpp>                 // for boost::exit_success
 #include <boost/integer/static_min_max.hpp>  // for boost::static_signed_min, etc.
@ -37,57 +38,57 @@ test_main
    // Two positives
    cout << "Doing tests with two positive values." << endl;
-    BOOST_CHECK( (static_signed_min< 9, 14>::value) ==  9 );
+    BOOST_TEST( (static_signed_min< 9, 14>::value) ==  9 );
-    BOOST_CHECK( (static_signed_max< 9, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_max< 9, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_min<14,  9>::value) ==  9 );
+    BOOST_TEST( (static_signed_min<14,  9>::value) ==  9 );
-    BOOST_CHECK( (static_signed_max<14,  9>::value) == 14 );
+    BOOST_TEST( (static_signed_max<14,  9>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min< 9, 14>::value) ==  9 );
+    BOOST_TEST( (static_unsigned_min< 9, 14>::value) ==  9 );
-    BOOST_CHECK( (static_unsigned_max< 9, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max< 9, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14,  9>::value) ==  9 );
+    BOOST_TEST( (static_unsigned_min<14,  9>::value) ==  9 );
-    BOOST_CHECK( (static_unsigned_max<14,  9>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max<14,  9>::value) == 14 );
    // Two negatives
    cout << "Doing tests with two negative values." << endl;
-    BOOST_CHECK( (static_signed_min<  -8, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_min<  -8, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<  -8, -101>::value) ==   -8 );
+    BOOST_TEST( (static_signed_max<  -8, -101>::value) ==   -8 );
-    BOOST_CHECK( (static_signed_min<-101,   -8>::value) == -101 );
+    BOOST_TEST( (static_signed_min<-101,   -8>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<-101,   -8>::value) ==   -8 );
+    BOOST_TEST( (static_signed_max<-101,   -8>::value) ==   -8 );
    // With zero
    cout << "Doing tests with zero and a positive or negative value." << endl;
-    BOOST_CHECK( (static_signed_min< 0, 14>::value) ==  0 );
+    BOOST_TEST( (static_signed_min< 0, 14>::value) ==  0 );
-    BOOST_CHECK( (static_signed_max< 0, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_max< 0, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_min<14,  0>::value) ==  0 );
+    BOOST_TEST( (static_signed_min<14,  0>::value) ==  0 );
-    BOOST_CHECK( (static_signed_max<14,  0>::value) == 14 );
+    BOOST_TEST( (static_signed_max<14,  0>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min< 0, 14>::value) ==  0 );
+    BOOST_TEST( (static_unsigned_min< 0, 14>::value) ==  0 );
-    BOOST_CHECK( (static_unsigned_max< 0, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max< 0, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14,  0>::value) ==  0 );
+    BOOST_TEST( (static_unsigned_min<14,  0>::value) ==  0 );
-    BOOST_CHECK( (static_unsigned_max<14,  0>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max<14,  0>::value) == 14 );
-    BOOST_CHECK( (static_signed_min<   0, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_min<   0, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<   0, -101>::value) ==    0 );
+    BOOST_TEST( (static_signed_max<   0, -101>::value) ==    0 );
-    BOOST_CHECK( (static_signed_min<-101,    0>::value) == -101 );
+    BOOST_TEST( (static_signed_min<-101,    0>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<-101,    0>::value) ==    0 );
+    BOOST_TEST( (static_signed_max<-101,    0>::value) ==    0 );
    // With identical
    cout << "Doing tests with two identical values." << endl;
-    BOOST_CHECK( (static_signed_min<0, 0>::value) == 0 );
+    BOOST_TEST( (static_signed_min<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_signed_max<0, 0>::value) == 0 );
+    BOOST_TEST( (static_signed_max<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_unsigned_min<0, 0>::value) == 0 );
+    BOOST_TEST( (static_unsigned_min<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_unsigned_max<0, 0>::value) == 0 );
+    BOOST_TEST( (static_unsigned_max<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_signed_min<14, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_min<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_max<14, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_max<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_max<14, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_min< -101, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_min< -101, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max< -101, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max< -101, -101>::value) == -101 );
    return boost::exit_success;
 }