Branch for 2nd try at V2 removal

[SVN r77497]
Apply patch from Vincent Botet Escriba: fix check for size > long long.
2025-06-25 20:11:41 +02:00 · 2012-03-23 12:04:44 +00:00 · 2012-02-24 16:57:13 +00:00 · 2011-12-24 17:29:03 +00:00 · 2011-02-12 15:06:21 +00:00 · 2011-01-13 13:43:08 +00:00
39 changed files with 5247 additions and 1216 deletions
--- a/cstdint.htm
+++ b/cstdint.htm
@ -1,78 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <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="../../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
 writing portable code that requires certain integer widths.  All typedef's are in namespace boost.</p>
 <p>The specifications are based on the ISO/IEC 9899:1999 C Language standard
 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="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
 signed integer type.&nbsp; Similarly, the typedef <code>uint#_t</code>
 designates and unsigned integer type of exactly # bits.</p>
 <p>These types are optional. However, if an implementation provides integer
 types with widths of 8, 16, 32, or 64 bits, it shall define the corresponding
 typedef names.</p>
 <h2>Minimum-width integer types</h2>
 <p>The typedef <code>int_least#_t</code>, with # replaced by the width,&nbsp;
 designates a signed integer type with a width of at least # bits, such that no
 signed integer type with lesser size has at least the specified width. Thus, <code>int_least32_t</code>
 denotes a signed integer type with a width of at least 32 bits. Similarly, the
 typedef name <code>uint_least#_t</code> designates an unsigned integer type with
 a width of at least # bits, such that no unsigned integer type with lesser size
 has at least the specified width.</p>
 <p>Required minimum-width integer types:</p>
 <ul>
  <li><code>int_least8_t</code></li>
  <li><code>int_least16_t</code></li>
  <li><code>int_least32_t</code></li>
  <li><code>uint_least8_t</code></li>
  <li><code>uint_least16_t</code></li>
  <li><code>uint_least32_t</code></li>
 </ul>
 <p>All other minimum-width integer types are optional.</p>
 <h2>Fastest minimum-width integer types</h2>
 <p>The typedef <code>int_fast#_t</code>, with # replaced by the width,
 designates the fastest signed integer type with a width of at least # bits.
 Similarly, the typedef name <code>uint_fast#_t</code> designates the fastest
 unsigned integer type with a width of at least # bits.</p>
 <p>There is no guarantee that these types are fastest for all purposes.&nbsp; In
 any case, however, they satisfy&nbsp; the signedness and width requirements.</p>
 <p>Required fastest minimum-width integer types:</p>
 <ul>
  <li><code>int_fast8_t</code></li>
  <li><code>int_fast16_t</code></li>
  <li><code>int_fast32_t</code></li>
  <li><code>uint_fast8_t</code></li>
  <li><code>uint_fast16_t</code></li>
  <li><code>uint_fast32_t</code></li>
 </ul>
 <p>All other fastest minimum-width integer types are optional.</p>
 <h2>Greatest-width integer types</h2>
 <p>The typedef <code>intmax_t </code>designates a signed integer type capable of
 representing any value of any signed integer type.</p>
 <p>The typedef <code>uintmax_t</code> designates an unsigned integer type
 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 -->10 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14373" -->
 </p>
 <p>&nbsp;</p>
 </body>
 </html>
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -0,0 +1,55 @@
 # Copyright John Maddock 2005. Use, modification, and distribution are
 # subject to 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)
 using quickbook ;
 xml integer : integer.qbk ;
 boostbook standalone
    :
        integer
    :
        # HTML options first:
        # Use graphics not text for navigation:
        <xsl:param>navig.graphics=1
        # How far down we chunk nested sections, basically all of them:
        <xsl:param>chunk.section.depth=1
        # Don't put the first section on the same page as the TOC:
        <xsl:param>chunk.first.sections=0
        # How far down sections get TOC's
        <xsl:param>toc.section.depth=1
        # Max depth in each TOC:
        <xsl:param>toc.max.depth=1
        # How far down we go with TOC's
        <xsl:param>generate.section.toc.level=4
        # Path for links to Boost:
        <xsl:param>boost.root=../../../..
        # PDF Options:
        # TOC Generation: this is needed for FOP-0.9 and later:
        <xsl:param>fop1.extensions=0
        # Or enable this if you're using XEP:
        <xsl:param>xep.extensions=1
        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
        <xsl:param>fop.extensions=0
        # No indent on body text:
        <xsl:param>body.start.indent=0pt
        # Margin size:
        <xsl:param>page.margin.inner=0.5in
        # Margin size:
        <xsl:param>page.margin.outer=0.5in
        # Yes, we want graphics for admonishments:
        <xsl:param>admon.graphics=1
        # Set this one for PDF generation *only*:
        # default pnd graphics are awful in PDF form,
        # better use SVG's instead:
        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/regex/doc/html
    ;
 install pdf-install : standalone : <location>. <install-type>PDF ;
--- a/doc/html/boost_integer/cstdint.html
+++ b/doc/html/boost_integer/cstdint.html
@ -0,0 +1,289 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Standard Integer Types</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Boost.Integer">
 <link rel="up" href="../index.html" title="Boost.Integer">
 <link rel="prev" href="../index.html" title="Boost.Integer">
 <link rel="next" href="traits.html" title="Integer Traits">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="traits.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_integer.cstdint"></a><a class="link" href="cstdint.html" title="Standard Integer Types"> Standard Integer Types</a>
 </h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.overview">Overview</a></span></dt>
 <dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.rationale"> Rationale</a></span></dt>
 <dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.ce"> <span class="emphasis"><em>Caveat emptor</em></span></a></span></dt>
 <dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.exact_width_integer_types">Exact-width
      integer types</a></span></dt>
 <dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.minimum_width_integer_types">Minimum-width
      integer types</a></span></dt>
 <dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.fastest_minimum_width_integer_types">Fastest
      minimum-width integer types</a></span></dt>
 <dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.greatest_width_integer_types">Greatest-width
      integer types</a></span></dt>
 <dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.integer_constant_macros">Integer
      Constant Macros</a></span></dt>
 </dl></div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.cstdint.overview"></a><a class="link" href="cstdint.html#boost_integer.cstdint.overview" title="Overview">Overview</a>
 </h3></div></div></div>
 <p>
        The header <code class="literal"><a href="../../../../../boost/cstdint.hpp" target="_top">&lt;boost/cstdint.hpp&gt;</a></code>
        provides the typedef's useful for writing portable code that requires certain
        integer widths. All typedef's are in namespace boost.
      </p>
 <p>
        The specifications for these types are based on the ISO/IEC 9899:1999 C Language
        standard header &lt;stdint.h&gt;. The 64-bit types required by the C standard
        are <span class="emphasis"><em>not required</em></span> in the boost header, and may not be
        supplied for all platforms/compilers, because <code class="literal">long long</code>
        is not [yet] included in the C++ standard.
      </p>
 <p>
        See <a href="../../../test/cstdint_test.cpp" target="_top">cstdint_test.cpp</a> for
        a test program.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.cstdint.rationale"></a><a class="link" href="cstdint.html#boost_integer.cstdint.rationale" title="Rationale"> Rationale</a>
 </h3></div></div></div>
 <p>
        The organization of the Boost.Integer headers and classes is designed to
        take advantage of &lt;stdint.h&gt; types from the 1999 C standard without
        causing undefined behavior in terms of the 1998 C++ standard. The header
        &lt;boost/cstdint.hpp&gt; makes the standard integer types safely available
        in namespace <code class="literal">boost</code> without placing any names in namespace
        <code class="literal">std</code>. The intension is to complement rather than compete
        with the C++ Standard Library. Should some future C++ standard include &lt;stdint.h&gt;
        and &lt;cstdint&gt;, then &lt;boost/cstdint.hpp&gt; will continue to function,
        but will become redundant and may be safely deprecated.
      </p>
 <p>
        Because these are boost headers, their names conform to boost header naming
        conventions rather than C++ Standard Library header naming conventions.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.cstdint.ce"></a><a class="link" href="cstdint.html#boost_integer.cstdint.ce" title="Caveat emptor"> <span class="emphasis"><em>Caveat emptor</em></span></a>
 </h3></div></div></div>
 <p>
        As an implementation artifact, certain C &lt;limits.h&gt; macro names may
        possibly be visible to users of &lt;boost/cstdint.hpp&gt;. Don't use these
        macros; they are not part of any Boost-specified interface. Use <code class="literal">boost::integer_traits&lt;&gt;</code>
        or <code class="literal">std::numeric_limits&lt;&gt;</code> instead.
      </p>
 <p>
        As another implementation artifact, certain C &lt;stdint.h&gt; typedef names
        may possibly be visible in the global namespace to users of &lt;boost/cstdint.hpp&gt;.
        Don't use these names, they are not part of any Boost-specified interface.
        Use the respective names in namespace <code class="literal">boost</code> instead.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.cstdint.exact_width_integer_types"></a><a class="link" href="cstdint.html#boost_integer.cstdint.exact_width_integer_types" title="Exact-width integer types">Exact-width
      integer types</a>
 </h3></div></div></div>
 <p>
        The typedef <code class="literal">int#_t</code>, with # replaced by the width, designates
        a signed integer type of exactly # bits; for example <code class="literal">int8_t</code>
        denotes an 8-bit signed integer type. Similarly, the typedef <code class="literal">uint#_t</code>
        designates an unsigned integer type of exactly # bits.
      </p>
 <p>
        These types are optional. However, if a platform supports integer types with
        widths of 8, 16, 32, 64, or any combination thereof, then &lt;boost/cstdint.hpp&gt;
        does provide the corresponding typedefs.
      </p>
 <p>
        The absence of int64_t and uint64_t is indicated by the macro <code class="computeroutput"><span class="identifier">BOOST_NO_INT64_T</span></code>.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.cstdint.minimum_width_integer_types"></a><a class="link" href="cstdint.html#boost_integer.cstdint.minimum_width_integer_types" title="Minimum-width integer types">Minimum-width
      integer types</a>
 </h3></div></div></div>
 <p>
        The typedef <code class="literal">int_least#_t</code>, with # replaced by the width,
        designates a signed integer type with a width of at least # bits, such that
        no signed integer type with lesser size has at least the specified width.
        Thus, <code class="literal">int_least32_t</code> denotes the smallest signed integer
        type with a width of at least 32 bits. Similarly, the typedef name <code class="literal">uint_least#_t</code>
        designates an unsigned integer type with a width of at least # bits, such
        that no unsigned integer type with lesser size has at least the specified
        width.
      </p>
 <p>
        The following minimum-width integer types are provided for all platforms:
      </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
            <code class="literal">int_least8_t</code>
          </li>
 <li class="listitem">
            <code class="literal">int_least16_t</code>
          </li>
 <li class="listitem">
            <code class="literal">int_least32_t</code>
          </li>
 <li class="listitem">
            <code class="literal">uint_least8_t</code>
          </li>
 <li class="listitem">
            <code class="literal">uint_least16_t</code>
          </li>
 <li class="listitem">
            <code class="literal">uint_least32_t</code>
          </li>
 </ul></div>
 <p>
        The following types are available only if, after including &lt;boost/cstdint.hpp&gt;,
        the macro BOOST_NO_INT64_T is not defined:
      </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
            <code class="literal">int_least64_t</code>
          </li>
 <li class="listitem">
            <code class="literal">uint_least64_t</code>
          </li>
 </ul></div>
 <p>
        All other minimum-width integer types are optional.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.cstdint.fastest_minimum_width_integer_types"></a><a class="link" href="cstdint.html#boost_integer.cstdint.fastest_minimum_width_integer_types" title="Fastest minimum-width integer types">Fastest
      minimum-width integer types</a>
 </h3></div></div></div>
 <p>
        The typedef <code class="literal">int_fast#_t</code>, with # replaced by the width,
        designates the fastest signed integer type with a width of at least # bits.
        Similarly, the typedef name <code class="literal">uint_fast#_t</code> designates the
        fastest unsigned integer type with a width of at least # bits.
      </p>
 <p>
        There is no guarantee that these types are fastest for all purposes. In any
        case, however, they satisfy the signedness and width requirements.
      </p>
 <p>
        The following fastest minimum-width integer types are provided for all platforms:
      </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
            <code class="literal">int_fast8_t</code>
          </li>
 <li class="listitem">
            <code class="literal">int_fast16_t</code>
          </li>
 <li class="listitem">
            <code class="literal">int_fast32_t</code>
          </li>
 <li class="listitem">
            <code class="literal">uint_fast8_t</code>
          </li>
 <li class="listitem">
            <code class="literal">uint_fast16_t</code>
          </li>
 <li class="listitem">
            <code class="literal">uint_fast32_t</code>
          </li>
 </ul></div>
 <p>
        The following types are available only if, after including &lt;boost/cstdint.hpp&gt;,
        the macro BOOST_NO_INT64_T is not defined:
      </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
            <code class="literal">int_fast64_t</code>
          </li>
 <li class="listitem">
            <code class="literal">uint_fast64_t</code>
          </li>
 </ul></div>
 <p>
        All other fastest minimum-width integer types are optional.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.cstdint.greatest_width_integer_types"></a><a class="link" href="cstdint.html#boost_integer.cstdint.greatest_width_integer_types" title="Greatest-width integer types">Greatest-width
      integer types</a>
 </h3></div></div></div>
 <p>
        The typedef <code class="literal">intmax_t </code>designates a signed integer type
        capable of representing any value of any signed integer type.
      </p>
 <p>
        The typedef <code class="literal">uintmax_t</code> designates an unsigned integer type
        capable of representing any value of any unsigned integer type.
      </p>
 <p>
        These types are provided for all platforms.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.cstdint.integer_constant_macros"></a><a class="link" href="cstdint.html#boost_integer.cstdint.integer_constant_macros" title="Integer Constant Macros">Integer
      Constant Macros</a>
 </h3></div></div></div>
 <p>
        The following macros are always defined after inclusion of this header, these
        allow integer constants of at least the specified width to be declared: INT8_C,
        UINT8_C, INT16_C, UINT16_C, INT32_C, UINT32_C, INTMAX_C, UINTMAX_C.
      </p>
 <p>
        The macros INT64_C and UINT64_C are also defined if the the macro BOOST_NO_INT64_T
        is not defined.
      </p>
 <p>
        The C99 macro __STDC_CONSTANT_MACROS is also defined as an artifact of the
        implementation.
      </p>
 <p>
        For example:
      </p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cstdint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="comment">// Here the constant 0x1FFFFFFFF has the correct suffix applied:
 </span><span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uint64_t</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">INT64_C</span><span class="special">(</span><span class="number">0</span><span class="identifier">x1FFFFFFFF</span><span class="special">);</span> 
 </pre>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
 <td align="right"><div class="copyright-footer">Copyright &#169; 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota,
      John Maddock<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" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="traits.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>
--- a/doc/html/boost_integer/history.html
+++ b/doc/html/boost_integer/history.html
@ -0,0 +1,82 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>History</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Boost.Integer">
 <link rel="up" href="../index.html" title="Boost.Integer">
 <link rel="prev" href="minmax.html" title="Compile time min/max calculation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="minmax.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_integer.history"></a><a class="link" href="history.html" title="History"> History</a>
 </h2></div></div></div>
 <a name="boost_integer.history.1_42_0"></a><h5>
 <a name="id766183"></a>
      <a class="link" href="history.html#boost_integer.history.1_42_0">1.42.0</a>
    </h5>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
          Reverted Trunk to release branch state (i.e. a "known good state").
        </li>
 <li class="listitem">
          Fixed issues: <a href="https://svn.boost.org/trac/boost/ticket/653" target="_top">653</a>,
          <a href="https://svn.boost.org/trac/boost/ticket/3084" target="_top">3084</a>,
          <a href="https://svn.boost.org/trac/boost/ticket/3177" target="_top">3177</a>,
          <a href="https://svn.boost.org/trac/boost/ticket/3180" target="_top">3180</a>,
          <a href="https://svn.boost.org/trac/boost/ticket/3548" target="_top">3568</a>,
          <a href="https://svn.boost.org/trac/boost/ticket/3657" target="_top">3657</a>,
          <a href="https://svn.boost.org/trac/boost/ticket/2134" target="_top">2134</a>.
        </li>
 <li class="listitem">
          Added long long support to <code class="literal">boost::static_log2</code>, <code class="literal">boost::static_signed_min</code>,
          <code class="literal">boost::static_signed_max</code>, <code class="literal">boost::static_unsigned_min</code><code class="literal">boost::static_unsigned_max</code>,
          when available.
        </li>
 <li class="listitem">
          The argument type and the result type of <code class="literal">boost::static_signed_min</code>
          etc are now typedef'd. Formerly, they were hardcoded as <code class="literal">unsigned
          long</code> and <code class="literal">int</code> respectively. Please, use the
          provided typedefs in new code (and update old code as soon as possible).
        </li>
 </ul></div>
 <a name="boost_integer.history.1_32_0"></a><h5>
 <a name="id766314"></a>
      <a class="link" href="history.html#boost_integer.history.1_32_0">1.32.0</a>
    </h5>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          The argument type and the result type of <code class="literal">boost::static_log2</code>
          are now typedef'd. Formerly, they were hardcoded as <code class="literal">unsigned long</code>
          and <code class="literal">int</code> respectively. Please, use the provided typedefs
          in new code (and update old code as soon as possible).
        </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
 <td align="right"><div class="copyright-footer">Copyright &#169; 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota,
      John Maddock<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" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="minmax.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
 </body>
 </html>
--- a/doc/html/boost_integer/integer.html
+++ b/doc/html/boost_integer/integer.html
@ -0,0 +1,432 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Integer Type Selection</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Boost.Integer">
 <link rel="up" href="../index.html" title="Boost.Integer">
 <link rel="prev" href="traits.html" title="Integer Traits">
 <link rel="next" href="mask.html" title="Integer Masks">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="traits.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mask.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_integer.integer"></a><a class="link" href="integer.html" title="Integer Type Selection"> Integer Type Selection</a>
 </h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="integer.html#boost_integer.integer.synopsis"> Synopsis</a></span></dt>
 <dt><span class="section"><a href="integer.html#boost_integer.integer.easiest"> Easiest-to-Manipulate
      Types</a></span></dt>
 <dt><span class="section"><a href="integer.html#boost_integer.integer.sized"> Sized Types</a></span></dt>
 <dt><span class="section"><a href="integer.html#boost_integer.integer.example">Example</a></span></dt>
 <dt><span class="section"><a href="integer.html#boost_integer.integer.demonstration_program">Demonstration
      Program</a></span></dt>
 <dt><span class="section"><a href="integer.html#boost_integer.integer.rationale">Rationale</a></span></dt>
 <dt><span class="section"><a href="integer.html#boost_integer.integer.alternative">Alternative</a></span></dt>
 <dt><span class="section"><a href="integer.html#boost_integer.integer.credits">Credits</a></span></dt>
 </dl></div>
 <p>
      The <a href="../../../../../boost/integer.hpp" target="_top">&lt;boost/integer.hpp&gt;</a>
      type selection templates allow integer types to be selected based on desired
      characteristics such as number of bits or maximum value. This facility is particularly
      useful for solving generic programming problems.
    </p>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.integer.synopsis"></a><a class="link" href="integer.html#boost_integer.integer.synopsis" title="Synopsis"> Synopsis</a>
 </h3></div></div></div>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
 <span class="special">{</span>
  <span class="comment">//  fast integers from least integers
 </span>  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">LeastInt</span><span class="special">&gt;</span>
  <span class="keyword">struct</span> <span class="identifier">int_fast_t</span>
  <span class="special">{</span>
      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">type</span><span class="special">;</span>
  <span class="special">};</span>
  <span class="comment">//  signed
 </span>  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">Bits</span><span class="special">&gt;</span>
  <span class="keyword">struct</span> <span class="identifier">int_t</span> 
  <span class="special">{</span>
      <span class="comment">/* Member exact may or may not be defined depending upon Bits */</span>
      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">exact</span><span class="special">;</span>
      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
  <span class="special">};</span>
  <span class="comment">//  unsigned
 </span>  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">Bits</span><span class="special">&gt;</span>
  <span class="keyword">struct</span> <span class="identifier">uint_t</span> 
  <span class="special">{</span>
      <span class="comment">/* Member exact may or may not be defined depending upon Bits */</span>
      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">exact</span><span class="special">;</span>
      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
  <span class="special">};</span>
  <span class="comment">//  signed
 </span>  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">MaxValue</span><span class="special">&gt;</span>
  <span class="keyword">struct</span> <span class="identifier">int_max_value_t</span> 
  <span class="special">{</span>
      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
  <span class="special">};</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">MinValue</span><span class="special">&gt;</span>
  <span class="keyword">struct</span> <span class="identifier">int_min_value_t</span> 
  <span class="special">{</span>
      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
  <span class="special">};</span>
  <span class="comment">//  unsigned
 </span>  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">Value</span><span class="special">&gt;</span>
  <span class="keyword">struct</span> <span class="identifier">uint_value_t</span> 
  <span class="special">{</span>
      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
  <span class="special">};</span>
 <span class="special">}</span> <span class="comment">// namespace boost
 </span></pre>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.integer.easiest"></a><a class="link" href="integer.html#boost_integer.integer.easiest" title="Easiest-to-Manipulate Types"> Easiest-to-Manipulate
      Types</a>
 </h3></div></div></div>
 <p>
        The <code class="literal">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 class="literal">char</code> objects may go faster if they were converted
        to <code class="literal">int</code> objects before processing. The input type, passed
        as the only template parameter, must be a built-in integral type, except
        <code class="literal">bool</code>. Unsigned integral types can be used, as well as
        signed integral types. The output type is given as the nested type <code class="literal">fast</code>.
      </p>
 <p>
        <span class="bold"><strong>Implementation Notes:</strong></span> By default, the output
        type is identical to the input type. Eventually, this code's implementation
        should be customized for each platform to give accurate mappings between
        the built-in types and the easiest-to-manipulate built-in types. Also, there
        is no guarantee that the output type actually is easier to manipulate than
        the input type.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.integer.sized"></a><a class="link" href="integer.html#boost_integer.integer.sized" title="Sized Types"> Sized Types</a>
 </h3></div></div></div>
 <p>
        The <code class="literal">int_t</code>, <code class="literal">uint_t</code>, <code class="literal">int_max_value_t</code>,
        <code class="literal">int_min_value_t</code>, and <code class="literal">uint_value_t</code> class
        templates find the most appropiate built-in integral type for the given template
        parameter. This type is given by the nested type <code class="literal">least</code>.
        The easiest-to-manipulate version of that type is given by the nested type
        <code class="literal">fast</code>. The following table describes each template's criteria.
      </p>
 <div class="table">
 <a name="boost_integer.integer.sized.criteria_for_the_sized_type_class_templates"></a><p class="title"><b>Table&#160;1.&#160;Criteria for the Sized Type Class Templates</b></p>
 <div class="table-contents"><table class="table" summary="Criteria for the Sized Type Class Templates">
 <colgroup>
 <col>
 <col>
 </colgroup>
 <thead><tr>
 <th>
                <p>
                  Class Template
                </p>
              </th>
 <th>
                <p>
                  Template Parameter Mapping
                </p>
              </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::int_t&lt;N&gt;::least</code>
                </p>
              </td>
 <td>
                <p>
                  The smallest, built-in, signed integral type with at least <span class="emphasis"><em>N</em></span>
                  bits, including the sign bit. The parameter should be a positive
                  number. A compile-time error results if the parameter is larger
                  than the number of bits in the largest integer type.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::int_t&lt;N&gt;::fast</code>
                </p>
              </td>
 <td>
                <p>
                  The easiest-to-manipulate, built-in, signed integral type with
                  at least <span class="emphasis"><em>N</em></span> bits, including the sign bit. The
                  parameter should be a positive number. A compile-time error results
                  if the parameter is larger than the number of bits in the largest
                  integer type.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::int_t&lt;N&gt;::exact</code>
                </p>
              </td>
 <td>
                <p>
                  A built-in, signed integral type with exactly <span class="emphasis"><em>N</em></span>
                  bits, including the sign bit. The parameter should be a positive
                  number. Note that the member <span class="emphasis"><em>exact</em></span> is defined
                  <span class="bold"><strong>only</strong></span> if there exists a type with
                  exactly <span class="emphasis"><em>N</em></span> bits.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::uint_t&lt;N&gt;::least</code>
                </p>
              </td>
 <td>
                <p>
                  The smallest, built-in, unsigned integral type with at least <span class="emphasis"><em>N</em></span>
                  bits. The parameter should be a positive number. A compile-time
                  error results if the parameter is larger than the number of bits
                  in the largest integer type.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::uint_t&lt;N&gt;::fast</code>
                </p>
              </td>
 <td>
                <p>
                  The easiest-to-manipulate, built-in, unsigned integral type with
                  at least <span class="emphasis"><em>N</em></span> bits. The parameter should be a
                  positive number. A compile-time error results if the parameter
                  is larger than the number of bits in the largest integer type.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::uint_t&lt;N&gt;::exact</code>
                </p>
              </td>
 <td>
                <p>
                  A built-in, unsigned integral type with exactly <span class="emphasis"><em>N</em></span>
                  bits. The parameter should be a positive number. A compile-time
                  error results if the parameter is larger than the number of bits
                  in the largest integer type. Note that the member <span class="emphasis"><em>exact</em></span>
                  is defined <span class="bold"><strong>only</strong></span> if there exists
                  a type with exactly N bits.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::int_max_value_t&lt;V&gt;::last</code>
                </p>
              </td>
 <td>
                <p>
                  The smallest, built-in, signed integral type that can hold all
                  the values in the inclusive range <span class="emphasis"><em>0 - V</em></span>. The
                  parameter should be a positive number.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::int_max_value_t&lt;V&gt;::fast</code>
                </p>
              </td>
 <td>
                <p>
                  The easiest-to-manipulate, built-in, signed integral type that
                  can hold all the values in the inclusive range <span class="emphasis"><em>0 - V</em></span>.
                  The parameter should be a positive number.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::int_min_value_t&lt;V&gt;::least</code>
                </p>
              </td>
 <td>
                <p>
                  The smallest, built-in, signed integral type that can hold all
                  the values in the inclusive range <span class="emphasis"><em>V - 0</em></span>. The
                  parameter should be a negative number.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::int_min_value_t&lt;V&gt;::fast</code>
                </p>
              </td>
 <td>
                <p>
                  The easiest-to-manipulate, built-in, signed integral type that
                  can hold all the values in the inclusive range <span class="emphasis"><em>V - 0</em></span>.
                  The parameter should be a negative number.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::uint_value_t&lt;V&gt;::least</code>
                </p>
              </td>
 <td>
                <p>
                  The smallest, built-in, unsigned integral type that can hold all
                  positive values up to and including <span class="emphasis"><em>V</em></span>. The
                  parameter should be a positive number.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">boost::uint_value_t&lt;V&gt;::fast</code>
                </p>
              </td>
 <td>
                <p>
                  The easiest-to-manipulate, built-in, unsigned integral type that
                  can hold all positive values up to and including <span class="emphasis"><em>V</em></span>.
                  The parameter should be a positive number.
                </p>
              </td>
 </tr>
 </tbody>
 </table></div>
 </div>
 <br class="table-break">
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.integer.example"></a><a class="link" href="integer.html#boost_integer.integer.example" title="Example">Example</a>
 </h3></div></div></div>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="comment">//...
 </span>
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 <span class="special">{</span>
    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_t</span><span class="special">&lt;</span><span class="number">24</span><span class="special">&gt;::</span><span class="identifier">least</span> <span class="identifier">my_var</span><span class="special">;</span>  <span class="comment">// my_var has at least 24-bits
 </span>    <span class="comment">//...
 </span>    <span class="comment">// This one is guarenteed not to be truncated:
 </span>    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_max_value_t</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;::</span><span class="identifier">least</span> <span class="identifier">my1000</span> <span class="special">=</span> <span class="number">1000</span><span class="special">;</span>
    <span class="comment">//...
 </span>    <span class="comment">// This one is guarenteed not to be truncated, and as fast
 </span>    <span class="comment">// to manipulate as possible, its size may be greater than
 </span>    <span class="comment">// that of my1000:
 </span>    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_max_value_t</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;::</span><span class="identifier">fast</span> <span class="identifier">my_fast1000</span> <span class="special">=</span> <span class="number">1000</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.integer.demonstration_program"></a><a class="link" href="integer.html#boost_integer.integer.demonstration_program" title="Demonstration Program">Demonstration
      Program</a>
 </h3></div></div></div>
 <p>
        The program <a href="../../../test/integer_test.cpp" target="_top">integer_test.cpp</a>
        is a simplistic demonstration of the results from instantiating various examples
        of the sized type class templates.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.integer.rationale"></a><a class="link" href="integer.html#boost_integer.integer.rationale" title="Rationale">Rationale</a>
 </h3></div></div></div>
 <p>
        The rationale for the design of the templates in this header includes:
      </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
            Avoid recursion because of concern about C++'s limited guaranteed recursion
            depth (17).
          </li>
 <li class="listitem">
            Avoid macros on general principles.
          </li>
 <li class="listitem">
            Try to keep the design as simple as possible.
          </li>
 </ul></div>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.integer.alternative"></a><a class="link" href="integer.html#boost_integer.integer.alternative" title="Alternative">Alternative</a>
 </h3></div></div></div>
 <p>
        If the number of bits required is known beforehand, it may be more appropriate
        to use the types supplied in <a href="../../../../../boost/cstdint.hpp" target="_top">&lt;boost/cstdint.hpp&gt;</a>.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.integer.credits"></a><a class="link" href="integer.html#boost_integer.integer.credits" title="Credits">Credits</a>
 </h3></div></div></div>
 <p>
        The author of most of the Boost integer type choosing templates is <a href="http://www.boost.org/people/beman_dawes.html" target="_top">Beman Dawes</a>. He
        gives thanks to Valentin Bonnard and <a href="http://www.boost.org/people/kevlin_henney.htm" target="_top">Kevlin
        Henney</a> for sharing their designs for similar templates. <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
        Walker</a> designed the value-based sized templates.
      </p>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
 <td align="right"><div class="copyright-footer">Copyright &#169; 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota,
      John Maddock<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" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="traits.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mask.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>
--- a/doc/html/boost_integer/log2.html
+++ b/doc/html/boost_integer/log2.html
@ -0,0 +1,151 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Compile Time log2 Calculation</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Boost.Integer">
 <link rel="up" href="../index.html" title="Boost.Integer">
 <link rel="prev" href="mask.html" title="Integer Masks">
 <link rel="next" href="minmax.html" title="Compile time min/max calculation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="mask.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="minmax.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_integer.log2"></a><a class="link" href="log2.html" title="Compile Time log2 Calculation"> Compile Time log2 Calculation</a>
 </h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="log2.html#boost_integer.log2.synopsis">Synopsis</a></span></dt>
 <dt><span class="section"><a href="log2.html#boost_integer.log2.usage">Usage</a></span></dt>
 <dt><span class="section"><a href="log2.html#boost_integer.log2.demonstration_program">Demonstration
      Program</a></span></dt>
 <dt><span class="section"><a href="log2.html#boost_integer.log2.rationale">Rationale</a></span></dt>
 <dt><span class="section"><a href="log2.html#boost_integer.log2.credits">Credits</a></span></dt>
 </dl></div>
 <p>
      The class template in <a href="../../../../../boost/integer/static_log2.hpp" target="_top">&lt;boost/integer/static_log2.hpp&gt;</a>
      determines the position of the highest bit in a given value. This facility
      is useful for solving generic programming problems.
    </p>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.log2.synopsis"></a><a class="link" href="log2.html#boost_integer.log2.synopsis" title="Synopsis">Synopsis</a>
 </h3></div></div></div>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
 <span class="special">{</span>
  <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_log2_argument_type</span><span class="special">;</span>
  <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_log2_result_type</span><span class="special">;</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_log2_argument_type</span> <span class="identifier">arg</span><span class="special">&gt;</span>
  <span class="keyword">struct</span> <span class="identifier">static_log2</span>
  <span class="special">{</span>
    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">static_log2_result_type</span> <span class="identifier">value</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
  <span class="special">};</span>
  <span class="keyword">template</span> <span class="special">&lt;</span> <span class="special">&gt;</span>
  <span class="keyword">struct</span> <span class="identifier">static_log2</span><span class="special">&lt;</span> <span class="number">0</span> <span class="special">&gt;</span>
  <span class="special">{</span>
    <span class="comment">// The logarithm of zero is undefined.
 </span>  <span class="special">};</span>
 <span class="special">}</span>  <span class="comment">// namespace boost
 </span></pre>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.log2.usage"></a><a class="link" href="log2.html#boost_integer.log2.usage" title="Usage">Usage</a>
 </h3></div></div></div>
 <p>
        The <code class="literal">boost::static_log2</code> class template takes one template
        parameter, a value of type <code class="literal">static_log2_argument_type</code>.
        The template only defines one member, <code class="literal">value</code>, which gives
        the truncated, base-two logarithm of the template argument.
      </p>
 <p>
        Since the logarithm of zero, for any base, is undefined, there is a specialization
        of <code class="literal">static_log2</code> for a template argument 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:
      </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
            <code class="literal">static_log2_argument_type</code> is an <span class="emphasis"><em>unsigned
            integer type</em></span> (C++ standard, 3.9.1p3).
          </li>
 <li class="listitem">
            <code class="literal">static_log2_result_type</code> is an <span class="emphasis"><em>integer type</em></span>
            (C++ standard, 3.9.1p7).
          </li>
 </ul></div>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.log2.demonstration_program"></a><a class="link" href="log2.html#boost_integer.log2.demonstration_program" title="Demonstration Program">Demonstration
      Program</a>
 </h3></div></div></div>
 <p>
        The program <a href="../../../test/static_log2_test.cpp" target="_top">static_log2_test.cpp</a>
        is a simplistic demonstration of the results from instantiating various examples
        of the binary logarithm class template.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.log2.rationale"></a><a class="link" href="log2.html#boost_integer.log2.rationale" title="Rationale">Rationale</a>
 </h3></div></div></div>
 <p>
        The base-two (binary) logarithm, abbreviated lb, function 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 available statically (<span class="emphasis"><em>i.e.</em></span> at compile-time).
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.log2.credits"></a><a class="link" href="log2.html#boost_integer.log2.credits" title="Credits">Credits</a>
 </h3></div></div></div>
 <p>
        The original version of the Boost binary logarithm class template was written
        by <a href="http://www.boost.org/people/daryle_walker.html" target="_top">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>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
 <td align="right"><div class="copyright-footer">Copyright &#169; 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota,
      John Maddock<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" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="mask.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="minmax.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>
--- a/doc/html/boost_integer/mask.html
+++ b/doc/html/boost_integer/mask.html
@ -0,0 +1,378 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Integer Masks</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Boost.Integer">
 <link rel="up" href="../index.html" title="Boost.Integer">
 <link rel="prev" href="integer.html" title="Integer Type Selection">
 <link rel="next" href="log2.html" title="Compile Time log2 Calculation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="integer.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="log2.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_integer.mask"></a><a class="link" href="mask.html" title="Integer Masks"> Integer Masks</a>
 </h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="mask.html#boost_integer.mask.overview">Overview</a></span></dt>
 <dt><span class="section"><a href="mask.html#boost_integer.mask.synopsis">Synopsis</a></span></dt>
 <dt><span class="section"><a href="mask.html#boost_integer.mask.single_bit_mask_class_template">Single
      Bit-Mask Class Template</a></span></dt>
 <dt><span class="section"><a href="mask.html#boost_integer.mask.group_bit_mask_class_template">Group
      Bit-Mask Class Template</a></span></dt>
 <dt><span class="section"><a href="mask.html#boost_integer.mask.implementation_notes">Implementation
      Notes</a></span></dt>
 <dt><span class="section"><a href="mask.html#boost_integer.mask.example">Example</a></span></dt>
 <dt><span class="section"><a href="mask.html#boost_integer.mask.demonstration_program">Demonstration
      Program</a></span></dt>
 <dt><span class="section"><a href="mask.html#boost_integer.mask.rationale">Rationale</a></span></dt>
 <dt><span class="section"><a href="mask.html#boost_integer.mask.credits">Credits</a></span></dt>
 </dl></div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.mask.overview"></a><a class="link" href="mask.html#boost_integer.mask.overview" title="Overview">Overview</a>
 </h3></div></div></div>
 <p>
        The class templates in <a href="../../../../../boost/integer/integer_mask.hpp" target="_top">&lt;boost/integer/integer_mask.hpp&gt;</a>
        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 class="link" href="integer.html" title="Integer Type Selection">integer
        type selection templates</a> header.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.mask.synopsis"></a><a class="link" href="mask.html#boost_integer.mask.synopsis" title="Synopsis">Synopsis</a>
 </h3></div></div></div>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cstddef</span><span class="special">&gt;</span>  <span class="comment">// for std::size_t
 </span>
 <span class="keyword">namespace</span> <span class="identifier">boost</span>
 <span class="special">{</span>
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Bit</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">high_bit_mask_t</span>
 <span class="special">{</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">fast</span><span class="special">;</span>
    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">least</span>       <span class="identifier">high_bit</span>       <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">fast</span>        <span class="identifier">high_bit_fast</span>  <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">bit_position</span>   <span class="special">=</span> <span class="identifier">Bit</span><span class="special">;</span>
 <span class="special">};</span>
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Bits</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">low_bits_mask_t</span>
 <span class="special">{</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">fast</span><span class="special">;</span>
    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">least</span>       <span class="identifier">sig_bits</span>       <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">fast</span>        <span class="identifier">sig_bits_fast</span>  <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">bit_count</span>      <span class="special">=</span> <span class="identifier">Bits</span><span class="special">;</span>
 <span class="special">};</span>
 <span class="comment">// Specializations for low_bits_mask_t exist for certain bit counts.
 </span>
 <span class="special">}</span>  <span class="comment">// namespace boost
 </span></pre>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.mask.single_bit_mask_class_template"></a><a class="link" href="mask.html#boost_integer.mask.single_bit_mask_class_template" title="Single Bit-Mask Class Template">Single
      Bit-Mask Class Template</a>
 </h3></div></div></div>
 <p>
        The <code class="literal">boost::high_bit_mask_t</code> class template provides constants
        for bit masks representing the bit at a certain position. The masks are equivalent
        to the value 2<sup>Bit</sup>, where <code class="literal">Bit</code> is the template parameter.
        The bit position must be a nonnegative number from zero to <span class="emphasis"><em>Max</em></span>,
        where Max is one less than the number of bits supported by the largest unsigned
        built-in integral type. The following table describes the members of an instantiation
        of <code class="literal">high_bit_mask_t</code>.
      </p>
 <div class="table">
 <a name="boost_integer.mask.single_bit_mask_class_template.members_of_the__boost__high_bit_mask_t__class_template"></a><p class="title"><b>Table&#160;2.&#160;Members of the `boost::high_bit_mask_t` Class Template</b></p>
 <div class="table-contents"><table class="table" summary="Members of the `boost::high_bit_mask_t` Class Template">
 <colgroup>
 <col>
 <col>
 </colgroup>
 <thead><tr>
 <th>
                <p>
                  Member
                </p>
              </th>
 <th>
                <p>
                  Meaning
                </p>
              </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
                <p>
                  <code class="literal">least</code>
                </p>
              </td>
 <td>
                <p>
                  The smallest, unsigned, built-in type that supports the given bit
                  position.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">fast</code>
                </p>
              </td>
 <td>
                <p>
                  The easiest-to-manipulate analog of <code class="literal">least</code>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">high_bit</code>
                </p>
              </td>
 <td>
                <p>
                  A <code class="literal">least</code> constant of the value 2<sup>Bit</sup>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">high_bit_fast</code>
                </p>
              </td>
 <td>
                <p>
                  A <code class="literal">fast</code> analog of <code class="literal">high_bit</code>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">bit_position</code>
                </p>
              </td>
 <td>
                <p>
                  The value of the template parameter, in case its needed from a
                  renamed instantiation of the class template.
                </p>
              </td>
 </tr>
 </tbody>
 </table></div>
 </div>
 <br class="table-break">
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.mask.group_bit_mask_class_template"></a><a class="link" href="mask.html#boost_integer.mask.group_bit_mask_class_template" title="Group Bit-Mask Class Template">Group
      Bit-Mask Class Template</a>
 </h3></div></div></div>
 <p>
        The <code class="literal">boost::low_bits_mask_t</code> class template provides constants
        for bit masks equivalent to the value (2<sup>Bits</sup> - 1), where <code class="literal">Bits</code>
        is the template parameter. The parameter <code class="literal">Bits</code> must be
        a non-negative integer from zero to <span class="emphasis"><em>Max</em></span>, where Max is
        the number of bits supported by the largest, unsigned, built-in integral
        type. The following table describes the members of <code class="literal">low_bits_mask_t</code>.
      </p>
 <div class="table">
 <a name="boost_integer.mask.group_bit_mask_class_template.members_of_the___boost__low_bits_mask_t__class_template"></a><p class="title"><b>Table&#160;3.&#160;Members of the [^boost::low_bits_mask_t] Class Template</b></p>
 <div class="table-contents"><table class="table" summary="Members of the [^boost::low_bits_mask_t] Class Template">
 <colgroup>
 <col>
 <col>
 </colgroup>
 <thead><tr>
 <th>
                <p>
                  Member
                </p>
              </th>
 <th>
                <p>
                  Meaning
                </p>
              </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
                <p>
                  <code class="literal">least</code>
                </p>
              </td>
 <td>
                <p>
                  The smallest, unsigned built-in type that supports the given bit
                  count.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">fast</code>
                </p>
              </td>
 <td>
                <p>
                  The easiest-to-manipulate analog of <code class="literal">least</code>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">sig_bits</code>
                </p>
              </td>
 <td>
                <p>
                  A <code class="literal">least</code> constant of the desired bit-masking
                  value.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">sig_bits_fast</code>
                </p>
              </td>
 <td>
                <p>
                  A <code class="literal">fast</code> analog of <code class="literal">sig_bits</code>.
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">bit_count</code>
                </p>
              </td>
 <td>
                <p>
                  The value of the template parameter, in case its needed from a
                  renamed instantiation of the class template.
                </p>
              </td>
 </tr>
 </tbody>
 </table></div>
 </div>
 <br class="table-break">
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.mask.implementation_notes"></a><a class="link" href="mask.html#boost_integer.mask.implementation_notes" title="Implementation Notes">Implementation
      Notes</a>
 </h3></div></div></div>
 <p>
        When <code class="literal">Bits</code> is the exact size of a built-in unsigned type,
        the implementation has to change to prevent undefined behavior. Therefore,
        there are specializations of <code class="literal">low_bits_mask_t</code> at those
        bit counts.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.mask.example"></a><a class="link" href="mask.html#boost_integer.mask.example" title="Example">Example</a>
 </h3></div></div></div>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">integer_mask</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="comment">//...
 </span>
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 <span class="special">{</span>
    <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">high_bit_mask_t</span><span class="special">&lt;</span><span class="number">29</span><span class="special">&gt;</span>  <span class="identifier">mask1_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">low_bits_mask_t</span><span class="special">&lt;</span><span class="number">15</span><span class="special">&gt;</span>  <span class="identifier">mask2_type</span><span class="special">;</span>
    <span class="identifier">mask1_type</span><span class="special">::</span><span class="identifier">least</span>  <span class="identifier">my_var1</span><span class="special">;</span>
    <span class="identifier">mask2_type</span><span class="special">::</span><span class="identifier">fast</span>   <span class="identifier">my_var2</span><span class="special">;</span>
    <span class="comment">//...
 </span>
    <span class="identifier">my_var1</span> <span class="special">|=</span> <span class="identifier">mask1_type</span><span class="special">::</span><span class="identifier">high_bit</span><span class="special">;</span>
    <span class="identifier">my_var2</span> <span class="special">&amp;=</span> <span class="identifier">mask2_type</span><span class="special">::</span><span class="identifier">sig_bits_fast</span><span class="special">;</span>
    <span class="comment">//...
 </span><span class="special">}</span>
 </pre>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.mask.demonstration_program"></a><a class="link" href="mask.html#boost_integer.mask.demonstration_program" title="Demonstration Program">Demonstration
      Program</a>
 </h3></div></div></div>
 <p>
        The program <a href="../../../test/integer_mask_test.cpp" target="_top">integer_mask_test.cpp</a>
        is a simplistic demonstration of the results from instantiating various examples
        of the bit mask class templates.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.mask.rationale"></a><a class="link" href="mask.html#boost_integer.mask.rationale" title="Rationale">Rationale</a>
 </h3></div></div></div>
 <p>
        The class templates in this header are an extension of the <a class="link" href="integer.html" title="Integer Type Selection">integer
        type selection class templates</a>. The new class templates provide the
        same sized types, but also convenient masks to use when extracting the highest
        or all the significant bits when the containing built-in type contains more
        bits. This prevents contamination of values by the higher, unused bits.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.mask.credits"></a><a class="link" href="mask.html#boost_integer.mask.credits" title="Credits">Credits</a>
 </h3></div></div></div>
 <p>
        The author of the Boost bit mask class templates is <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
        Walker</a>.
      </p>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
 <td align="right"><div class="copyright-footer">Copyright &#169; 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota,
      John Maddock<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" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="integer.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="log2.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>
--- a/doc/html/boost_integer/minmax.html
+++ b/doc/html/boost_integer/minmax.html
@ -0,0 +1,160 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Compile time min/max calculation</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Boost.Integer">
 <link rel="up" href="../index.html" title="Boost.Integer">
 <link rel="prev" href="log2.html" title="Compile Time log2 Calculation">
 <link rel="next" href="history.html" title="History">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="log2.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="history.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_integer.minmax"></a><a class="link" href="minmax.html" title="Compile time min/max calculation"> Compile time min/max calculation</a>
 </h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="minmax.html#boost_integer.minmax.synopsis">Synopsis</a></span></dt>
 <dt><span class="section"><a href="minmax.html#boost_integer.minmax.usage">Usage</a></span></dt>
 <dt><span class="section"><a href="minmax.html#boost_integer.minmax.example">Example</a></span></dt>
 <dt><span class="section"><a href="minmax.html#boost_integer.minmax.demonstration_program">Demonstration
      Program</a></span></dt>
 <dt><span class="section"><a href="minmax.html#boost_integer.minmax.rationale">Rationale</a></span></dt>
 <dt><span class="section"><a href="minmax.html#boost_integer.minmax.credits">Credits</a></span></dt>
 </dl></div>
 <p>
      The class templates in <a href="../../../../../boost/integer/static_min_max.hpp" target="_top">&lt;boost/integer/static_min_max.hpp&gt;</a>
      provide a compile-time evaluation of the minimum or maximum of two integers.
      These facilities are useful for generic programming problems.
    </p>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.minmax.synopsis"></a><a class="link" href="minmax.html#boost_integer.minmax.synopsis" title="Synopsis">Synopsis</a>
 </h3></div></div></div>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
 <span class="special">{</span>
 <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_min_max_signed_type</span><span class="special">;</span>
 <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_min_max_unsigned_type</span><span class="special">;</span>
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value2</span> <span class="special">&gt;</span>
    <span class="keyword">struct</span> <span class="identifier">static_signed_min</span><span class="special">;</span>
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value2</span><span class="special">&gt;</span>
    <span class="keyword">struct</span> <span class="identifier">static_signed_max</span><span class="special">;</span>
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value2</span><span class="special">&gt;</span>
    <span class="keyword">struct</span> <span class="identifier">static_unsigned_min</span><span class="special">;</span>
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value2</span><span class="special">&gt;</span>
    <span class="keyword">struct</span> <span class="identifier">static_unsigned_max</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.minmax.usage"></a><a class="link" href="minmax.html#boost_integer.minmax.usage" title="Usage">Usage</a>
 </h3></div></div></div>
 <p>
        The four class templates provide the combinations for finding the minimum
        or maximum of two <code class="literal">signed</code> or <code class="literal">unsigned</code>
        (<code class="literal">long</code>) parameters, <span class="emphasis"><em>Value1</em></span> and <span class="emphasis"><em>Value2</em></span>,
        at compile-time. Each template has a single static data member, <code class="literal">value</code>,
        which is set to the respective minimum or maximum of the template's parameters.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.minmax.example"></a><a class="link" href="minmax.html#boost_integer.minmax.example" title="Example">Example</a>
 </h3></div></div></div>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">static_min_max</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">AddendSize1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">AddendSize2</span> <span class="special">&gt;</span>
 <span class="keyword">class</span> <span class="identifier">adder</span>
 <span class="special">{</span>
 <span class="keyword">public</span><span class="special">:</span>
    <span class="keyword">static</span>  <span class="keyword">unsigned</span> <span class="keyword">long</span>  <span class="keyword">const</span>  <span class="identifier">addend1_size</span> <span class="special">=</span> <span class="identifier">AddendSize1</span><span class="special">;</span>
    <span class="keyword">static</span>  <span class="keyword">unsigned</span> <span class="keyword">long</span>  <span class="keyword">const</span>  <span class="identifier">addend2_size</span> <span class="special">=</span> <span class="identifier">AddendSize2</span><span class="special">;</span>
    <span class="keyword">static</span>  <span class="keyword">unsigned</span> <span class="keyword">long</span>  <span class="keyword">const</span>  <span class="identifier">sum_size</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">static_unsigned_max</span><span class="special">&lt;</span><span class="identifier">AddendSize1</span><span class="special">,</span> <span class="identifier">AddendSize2</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">+</span> <span class="number">1</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">int</span>  <span class="identifier">addend1_type</span><span class="special">[</span> <span class="identifier">addend1_size</span> <span class="special">];</span>
    <span class="keyword">typedef</span> <span class="keyword">int</span>  <span class="identifier">addend2_type</span><span class="special">[</span> <span class="identifier">addend2_size</span> <span class="special">];</span>
    <span class="keyword">typedef</span> <span class="keyword">int</span>  <span class="identifier">sum_type</span><span class="special">[</span> <span class="identifier">sum_size</span> <span class="special">];</span>
    <span class="keyword">void</span>  <span class="keyword">operator</span> <span class="special">()(</span> <span class="identifier">addend1_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">a1</span><span class="special">,</span> <span class="identifier">addend2_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">a2</span><span class="special">,</span> <span class="identifier">sum_type</span> <span class="special">&amp;</span><span class="identifier">s</span> <span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 <span class="special">};</span>
 <span class="comment">//...
 </span>
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 <span class="special">{</span>
    <span class="keyword">int</span> <span class="keyword">const</span>   <span class="identifier">a1</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</span><span class="special">,</span> <span class="number">4</span><span class="special">,</span> <span class="number">3</span> <span class="special">};</span>  <span class="comment">// 340
 </span>    <span class="keyword">int</span> <span class="keyword">const</span>   <span class="identifier">a2</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="number">9</span><span class="special">,</span> <span class="number">8</span> <span class="special">};</span>     <span class="comment">//  89
 </span>    <span class="keyword">int</span>         <span class="identifier">s</span><span class="special">[</span> <span class="number">4</span> <span class="special">];</span>
    <span class="identifier">adder</span><span class="special">&lt;</span><span class="number">3</span><span class="special">,</span><span class="number">2</span><span class="special">&gt;</span>  <span class="identifier">obj</span><span class="special">;</span>
    <span class="identifier">obj</span><span class="special">(</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">,</span> <span class="identifier">s</span> <span class="special">);</span>  <span class="comment">// 's' should be 429 or { 9, 2, 4, 0 }
 </span>    <span class="comment">//...
 </span><span class="special">}</span>
 </pre>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.minmax.demonstration_program"></a><a class="link" href="minmax.html#boost_integer.minmax.demonstration_program" title="Demonstration Program">Demonstration
      Program</a>
 </h3></div></div></div>
 <p>
        The program <a href="../../../test/static_min_max_test.cpp" target="_top">static_min_max_test.cpp</a>
        is a simplistic demonstration of various comparisons using the compile-time
        extrema class templates.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.minmax.rationale"></a><a class="link" href="minmax.html#boost_integer.minmax.rationale" title="Rationale">Rationale</a>
 </h3></div></div></div>
 <p>
        Sometimes the minimum or maximum of several values needs to be found for
        later compile-time processing, <span class="emphasis"><em>e.g.</em></span> for a bound for
        another class template.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.minmax.credits"></a><a class="link" href="minmax.html#boost_integer.minmax.credits" title="Credits">Credits</a>
 </h3></div></div></div>
 <p>
        The author of the Boost compile-time extrema class templates is <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
        Walker</a>.
      </p>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
 <td align="right"><div class="copyright-footer">Copyright &#169; 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota,
      John Maddock<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" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="log2.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="history.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>
--- a/doc/html/boost_integer/traits.html
+++ b/doc/html/boost_integer/traits.html
@ -0,0 +1,215 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Integer Traits</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Boost.Integer">
 <link rel="up" href="../index.html" title="Boost.Integer">
 <link rel="prev" href="cstdint.html" title="Standard Integer Types">
 <link rel="next" href="integer.html" title="Integer Type Selection">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="cstdint.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integer.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_integer.traits"></a><a class="link" href="traits.html" title="Integer Traits"> Integer Traits</a>
 </h2></div></div></div>
 <div class="toc"><dl>
 <dt><span class="section"><a href="traits.html#boost_integer.traits.motivation">Motivation</a></span></dt>
 <dt><span class="section"><a href="traits.html#boost_integer.traits.synopsis">Synopsis</a></span></dt>
 <dt><span class="section"><a href="traits.html#boost_integer.traits.description">Description</a></span></dt>
 <dt><span class="section"><a href="traits.html#boost_integer.traits.test_program">Test Program</a></span></dt>
 <dt><span class="section"><a href="traits.html#boost_integer.traits.acknowledgements">Acknowledgements</a></span></dt>
 </dl></div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.traits.motivation"></a><a class="link" href="traits.html#boost_integer.traits.motivation" title="Motivation">Motivation</a>
 </h3></div></div></div>
 <p>
        The C++ Standard Library &lt;limits&gt; header supplies a class template
        <code class="computeroutput"><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;</span></code>
        with specializations for each fundamental type.
      </p>
 <p>
        For integer types, the interesting members of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;</span></code> are:
      </p>
 <pre class="programlisting"><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_specialized</span><span class="special">;</span>      <span class="comment">// Will be true for integer types.
 </span><span class="keyword">static</span> <span class="identifier">T</span> <span class="identifier">min</span><span class="special">()</span> <span class="keyword">throw</span><span class="special">();</span>                <span class="comment">// Smallest representable value.
 </span><span class="keyword">static</span> <span class="identifier">T</span> <span class="identifier">max</span><span class="special">()</span> <span class="keyword">throw</span><span class="special">();</span>                <span class="comment">// Largest representable value.
 </span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">digits</span><span class="special">;</span>               <span class="comment">// For integers, the number of value bits.
 </span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">digits10</span><span class="special">;</span>             <span class="comment">// The number of base 10 digits that can be represented.
 </span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_signed</span><span class="special">;</span>           <span class="comment">// True if the type is signed.
 </span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_integer</span><span class="special">;</span>          <span class="comment">// Will be true for all integer types.
 </span></pre>
 <p>
        For many uses, these are sufficient. But min() and max() are problematical
        because they are not constant expressions (std::5.19), yet some usages require
        constant expressions.
      </p>
 <p>
        The template class <code class="literal">integer_traits</code> addresses this problem.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.traits.synopsis"></a><a class="link" href="traits.html#boost_integer.traits.synopsis" title="Synopsis">Synopsis</a>
 </h3></div></div></div>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
  <span class="keyword">class</span> <span class="identifier">integer_traits</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span>
  <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>
     <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_integral</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
     <span class="comment">//
 </span>     <span class="comment">// These members are defined only if T is a built-in
 </span>     <span class="comment">// integal type:
 </span>     <span class="comment">//
 </span>     <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="identifier">const_min</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
     <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="identifier">const_max</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
  <span class="special">};</span>
 <span class="special">}</span>
 </pre>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.traits.description"></a><a class="link" href="traits.html#boost_integer.traits.description" title="Description">Description</a>
 </h3></div></div></div>
 <p>
        Template class <code class="literal">integer_traits</code> is derived from <code class="literal">std::numeric_limits</code>.
        The primary specialization adds the single <code class="literal">bool</code> member
        <code class="literal">is_integral</code> with the compile-time constant value <code class="literal">false</code>.
        However, for all integral types <code class="literal">T</code> (std::3.9.1/7 [basic.fundamental]),
        there are specializations provided with the following compile-time constants
        defined:
      </p>
 <div class="informaltable"><table class="table">
 <colgroup>
 <col>
 <col>
 <col>
 </colgroup>
 <thead><tr>
 <th>
                <p>
                  member
                </p>
              </th>
 <th>
                <p>
                  type
                </p>
              </th>
 <th>
                <p>
                  value
                </p>
              </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
                <p>
                  <code class="literal">is_integral</code>
                </p>
              </td>
 <td>
                <p>
                  bool
                </p>
              </td>
 <td>
                <p>
                  <code class="literal">true</code>
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">const_min</code>
                </p>
              </td>
 <td>
                <p>
                  <code class="literal">T</code>
                </p>
              </td>
 <td>
                <p>
                  equivalent to <code class="literal">std::numeric_limits&lt;T&gt;::min()</code>
                </p>
              </td>
 </tr>
 <tr>
 <td>
                <p>
                  <code class="literal">const_max</code>
                </p>
              </td>
 <td>
                <p>
                  <code class="literal">T</code>
                </p>
              </td>
 <td>
                <p>
                  equivalent to <code class="literal">std::numeric_limits&lt;T&gt;::max()</code>
                </p>
              </td>
 </tr>
 </tbody>
 </table></div>
 <p>
        Note: The <span class="emphasis"><em>is_integral</em></span> flag is provided, because a user-defined
        integer class should specialize <code class="literal">std::numeric_limits&lt;&gt;::is_integer
        = true</code>, while compile-time constants <code class="literal">const_min</code>
        and <code class="literal">const_max</code> are not provided for that user-defined class,
        unless boost::integer_traits is also specialized.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.traits.test_program"></a><a class="link" href="traits.html#boost_integer.traits.test_program" title="Test Program">Test Program</a>
 </h3></div></div></div>
 <p>
        The program <code class="literal"><a href="../../../test/integer_traits_test.cpp" target="_top">integer_traits_test.cpp</a></code>
        exercises the <code class="literal">integer_traits</code> class.
      </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_integer.traits.acknowledgements"></a><a class="link" href="traits.html#boost_integer.traits.acknowledgements" title="Acknowledgements">Acknowledgements</a>
 </h3></div></div></div>
 <p>
        Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer
        traits idea on the boost mailing list in August 1999.
      </p>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
 <td align="right"><div class="copyright-footer">Copyright &#169; 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota,
      John Maddock<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" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="cstdint.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integer.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>
--- a/doc/html/index.html
+++ b/doc/html/index.html
@ -0,0 +1,246 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Boost.Integer</title>
 <link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="index.html" title="Boost.Integer">
 <link rel="next" href="boost_integer/cstdint.html" title="Standard Integer Types">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
 <td align="center"><a href="../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav"><a accesskey="n" href="boost_integer/cstdint.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
 <div class="article">
 <div class="titlepage">
 <div>
 <div><h2 class="title">
 <a name="boost_integer"></a>Boost.Integer</h2></div>
 <div><div class="authorgroup">
 <div class="author"><h3 class="author">
 <span class="firstname">Beman</span> <span class="surname">Dawes</span>
 </h3></div>
 <div class="author"><h3 class="author">
 <span class="firstname">Daryle</span> <span class="surname">Walker</span>
 </h3></div>
 <div class="author"><h3 class="author">
 <span class="firstname">Gennaro</span> <span class="surname">Prota</span>
 </h3></div>
 <div class="author"><h3 class="author">
 <span class="firstname">John</span> <span class="surname">Maddock</span>
 </h3></div>
 </div></div>
 <div><p class="copyright">Copyright &#169; 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota,
      John Maddock</p></div>
 <div><div class="legalnotice">
 <a name="id759732"></a><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" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></div>
 </div>
 <hr>
 </div>
 <div class="toc">
 <p><b>Table of Contents</b></p>
 <dl>
 <dt><span class="section"><a href="index.html#boost_integer.overview"> Overview</a></span></dt>
 <dt><span class="section"><a href="boost_integer/cstdint.html"> Standard Integer Types</a></span></dt>
 <dt><span class="section"><a href="boost_integer/traits.html"> Integer Traits</a></span></dt>
 <dt><span class="section"><a href="boost_integer/integer.html"> Integer Type Selection</a></span></dt>
 <dt><span class="section"><a href="boost_integer/mask.html"> Integer Masks</a></span></dt>
 <dt><span class="section"><a href="boost_integer/log2.html"> Compile Time log2 Calculation</a></span></dt>
 <dt><span class="section"><a href="boost_integer/minmax.html"> Compile time min/max calculation</a></span></dt>
 <dt><span class="section"><a href="boost_integer/history.html"> History</a></span></dt>
 </dl>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_integer.overview"></a><a class="link" href="index.html#boost_integer.overview" title="Overview"> Overview</a>
 </h2></div></div></div>
 <p>
      Boost.Integer provides integer type support, particularly helpful in generic
      programming. It provides standard C99 integer types, such as might be found
      in &lt;stdint.h&gt;, without requiring that header. It provides the means to
      select an integer type based upon its properties, like the number of bits or
      the maximum supported value, as well as compile-time bit mask selection. There
      is a derivative of std::numeric_limits that provides integral constant expressions
      for <code class="computeroutput"><span class="identifier">min</span></code> and <code class="computeroutput"><span class="identifier">max</span></code>.
      Finally, it provides two compile-time algorithms: determining the highest power
      of two in a compile-time value; and computing min and max of constant expressions.
    </p>
 <div class="informaltable"><table class="table">
 <colgroup>
 <col>
 <col>
 <col>
 </colgroup>
 <thead><tr>
 <th>
              <p>
                Component
              </p>
            </th>
 <th>
              <p>
                Header
              </p>
            </th>
 <th>
              <p>
                Purpose
              </p>
            </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
              <p>
                Forward Declarations.
              </p>
            </td>
 <td>
              <p>
                <code class="literal"><a href="../../../../boost/integer_fwd.hpp" target="_top">&lt;boost/integer_fwd.hpp&gt;</a></code>
              </p>
            </td>
 <td>
              <p>
                Forward declarations of classes and class templates - for use when
                just the name of a class is needed.
              </p>
            </td>
 </tr>
 <tr>
 <td>
              <p>
                <a class="link" href="boost_integer/cstdint.html" title="Standard Integer Types">Standard Integer Types</a>.
              </p>
            </td>
 <td>
              <p>
                <code class="literal"><a href="../../../../boost/cstdint.hpp" target="_top">&lt;boost/cstdint.hpp&gt;</a></code>
              </p>
            </td>
 <td>
              <p>
                Provides typedef's based on the 1999 C Standard header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">stdint</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span></code>, wrapped in namespace boost.
                This implementation may #include the compiler supplied <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">stdint</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span></code>, if present.
              </p>
            </td>
 </tr>
 <tr>
 <td>
              <p>
                <a class="link" href="boost_integer/traits.html" title="Integer Traits">Integer Traits</a>.
              </p>
            </td>
 <td>
              <p>
                <code class="literal"><a href="../../../../boost/integer_traits.hpp" target="_top">&lt;boost/integer_traits.hpp&gt;</a></code>
              </p>
            </td>
 <td>
              <p>
                Class template <code class="literal">boost::integer_traits</code>, derives
                from <code class="literal">std::numeric_limits</code> and adds <code class="literal">const_min</code>
                and <code class="literal">const_max</code> members.
              </p>
            </td>
 </tr>
 <tr>
 <td>
              <p>
                <a class="link" href="boost_integer/integer.html" title="Integer Type Selection">Integer Type Selection</a>.
              </p>
            </td>
 <td>
              <p>
                <code class="literal"><a href="../../../../boost/integer.hpp" target="_top">&lt;boost/integer.hpp&gt;</a></code>
              </p>
            </td>
 <td>
              <p>
                Templates for integer type selection based on properties such as
                maximum value or number of bits: Use to select the type of an integer
                when some property such as maximum value or number of bits is known.
                Useful for generic programming.
              </p>
            </td>
 </tr>
 <tr>
 <td>
              <p>
                <a class="link" href="boost_integer/mask.html" title="Integer Masks">Integer Masks</a>.
              </p>
            </td>
 <td>
              <p>
                <code class="literal"><a href="../../../../boost/integer/integer_mask.hpp" target="_top">&lt;boost/integer/integer_mask.hpp&gt;</a></code>
              </p>
            </td>
 <td>
              <p>
                Templates for the selection of integer masks, single or lowest group,
                based on the number of bits: Use to select a particular mask when
                the bit position(s) are based on a compile-time variable. Useful
                for generic programming.
              </p>
            </td>
 </tr>
 <tr>
 <td>
              <p>
                <a class="link" href="boost_integer/log2.html" title="Compile Time log2 Calculation">Compile time log2 Calculation</a>.
              </p>
            </td>
 <td>
              <p>
                <code class="literal"><a href="../../../../boost/integer/static_log2.hpp" target="_top">&lt;boost/integer/static_log2.hpp&gt;</a></code>
              </p>
            </td>
 <td>
              <p>
                Template for finding the highest power of two in a number: Use to
                find the bit-size/range based on a maximum value. Useful for generic
                programming.
              </p>
            </td>
 </tr>
 <tr>
 <td>
              <p>
                <a class="link" href="boost_integer/minmax.html" title="Compile time min/max calculation">Compile time min/max calculation</a>.
              </p>
            </td>
 <td>
              <p>
                <code class="literal"><a href="../../../../boost/integer/static_min_max.hpp" target="_top">&lt;boost/integer/static_min_max.hpp&gt;</a></code>
              </p>
            </td>
 <td>
              <p>
                Templates for finding the extrema of two numbers: Use to find a bound
                based on a minimum or maximum value. Useful for generic programming.
              </p>
            </td>
 </tr>
 </tbody>
 </table></div>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"><p><small>Last revised: July 08, 2010 at 20:45:20 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav"><a accesskey="n" href="boost_integer/cstdint.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
 </body>
 </html>
--- a/doc/integer.qbk
+++ b/doc/integer.qbk
@ -0,0 +1,840 @@
 [article Boost.Integer
    [quickbook 1.5]
    [copyright 2001-2009 Beman Dawes, Daryle Walker, Gennaro Prota, John Maddock]
    [purpose Integer Type Selection]
    [license
        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])
    ]
    [authors [Dawes, Beman], [Walker, Daryle], [Prota, Gennaro], [Maddock, John]]
    [/last-revision $Date: 2008-02-21 12:58:15 +0000 (Thu, 21 Feb 2008) $]
 ]
 [template super[x]'''<superscript>'''[x]'''</superscript>''']
 [section:overview Overview]
 Boost.Integer provides integer type support, particularly helpful in generic programming.  It provides standard 
 C99 integer types, such as might be found in <stdint.h>, without requiring that header.  
 It provides the means to select an integer type based upon its properties, like the number of bits or 
 the maximum supported value, as well as compile-time bit mask selection.  There is a derivative of
 std::numeric_limits that provides integral constant expressions for `min` and `max`.  
 Finally, it provides two compile-time algorithms: determining the highest power of two in a 
 compile-time value; and computing min and max of constant expressions.
 [table 
   [[Component][Header][Purpose]]
   [
      [Forward Declarations.]
      [[^[@../../../../boost/integer_fwd.hpp <boost/integer_fwd.hpp>]]]
      [Forward declarations of classes and class templates - for use when just the name of a class is needed.]
   ]
   [
      [[link boost_integer.cstdint Standard Integer Types].]
      [[^[@../../../../boost/cstdint.hpp <boost/cstdint.hpp>]]]
      [Provides typedef's based on the 1999 C Standard header `<stdint.h>`, wrapped in namespace boost. 
      This implementation may #include the compiler supplied `<stdint.h>`, if present.]
   ]
   [
      [[link boost_integer.traits Integer Traits].]
      [[^[@../../../../boost/integer_traits.hpp <boost/integer_traits.hpp>]]]
      [Class template [^boost::integer_traits], derives from [^std::numeric_limits] and adds [^const_min] and [^const_max] members.]
   ]
   [
      [[link boost_integer.integer Integer Type Selection].]
      [[^[@../../../../boost/integer.hpp <boost/integer.hpp>]]]
      [Templates for integer type selection based on properties such as maximum value or number of bits: 
      Use to select the type of an integer when some property such as maximum value or number of bits is known. 
      Useful for generic programming. ]
   ]
   [
      [[link boost_integer.mask Integer Masks].]
      [[^[@../../../../boost/integer/integer_mask.hpp <boost/integer/integer_mask.hpp>]]]
      [Templates for the selection of integer masks, single or lowest group, based on the number of bits: 
      Use to select a particular mask when the bit position(s) are based on a compile-time variable. Useful for generic programming. ]
   ]
   [
      [[link boost_integer.log2 Compile time log2 Calculation].]
      [[^[@../../../../boost/integer/static_log2.hpp <boost/integer/static_log2.hpp>]]]
      [Template for finding the highest power of two in a number: 
      Use to find the bit-size/range based on a maximum value. Useful for generic programming. ]
   ]
   [
      [[link boost_integer.minmax Compile time min/max calculation].]
      [[^[@../../../../boost/integer/static_min_max.hpp <boost/integer/static_min_max.hpp>]]]
      [Templates for finding the extrema of two numbers: 
      Use to find a bound based on a minimum or maximum value. Useful for generic programming. ]
   ]
 ]
 [endsect]
 [section:cstdint Standard Integer Types]
 [section Overview]
 The header [^[@../../../../boost/cstdint.hpp <boost/cstdint.hpp>]] provides the typedef's useful 
 for writing portable code that requires certain integer widths. All typedef's are in namespace boost.
 The specifications for these types are based on the ISO/IEC 9899:1999 C Language standard header <stdint.h>.  
 The 64-bit types required by the C standard are ['not required] in the boost header, 
 and may not be supplied for all platforms/compilers, because [^long long] is not [yet] included in the C++ standard.
 See [@../../test/cstdint_test.cpp cstdint_test.cpp] for a test program.
 [endsect]
 [section:rationale Rationale]
 The organization of the Boost.Integer headers and classes is designed to take advantage of <stdint.h> types from the 
 1999 C standard without causing 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]. The intension is to complement rather than compete 
 with the C++ Standard Library. Should some future C++ standard include <stdint.h> and <cstdint>, 
 then <boost/cstdint.hpp> will continue to function, but will become redundant and may be safely deprecated.
 Because these are boost headers, their names conform to boost header naming conventions rather than 
 C++ Standard Library header naming conventions.
 [endsect]
 [section:ce ['Caveat emptor]]
 As an implementation artifact, certain C <limits.h> macro names may possibly be 
 visible to users of <boost/cstdint.hpp>. Don't use these macros; they are not part of 
 any Boost-specified interface. Use [^boost::integer_traits<>] or [^std::numeric_limits<>] instead.
 As another implementation artifact, certain C <stdint.h> typedef names may possibly be visible 
 in the global namespace to users of <boost/cstdint.hpp>. Don't use these names, they are not part of 
 any Boost-specified interface. Use the respective names in namespace [^boost] instead.
 [endsect]
 [section Exact-width integer types]
 The typedef [^int#_t], with # replaced by the width, designates a signed integer type of exactly # bits; 
 for example [^int8_t] denotes an 8-bit signed integer type.  Similarly, the typedef [^uint#_t] designates an unsigned 
 integer type of exactly # bits.
 These types are optional. However, if a platform supports integer types with widths of 
 8, 16, 32, 64, or any combination thereof, then <boost/cstdint.hpp> does provide the 
 corresponding typedefs.
 The absence of int64_t and uint64_t is indicated by the macro `BOOST_NO_INT64_T`.
 [endsect] 
 [section Minimum-width integer types]
 The typedef [^int_least#_t], with # replaced by the width,  designates a signed integer type with a width 
 of at least # bits, such that no signed integer type with lesser size has at least the specified width. 
 Thus, [^int_least32_t] denotes the smallest signed integer type with a width of at least 32 bits. 
 Similarly, the typedef name [^uint_least#_t] designates an unsigned integer type with a width of at least # bits, 
 such that no unsigned integer type with lesser size has at least the specified width.
 The following minimum-width integer types are provided for all platforms:
 * [^int_least8_t]
 * [^int_least16_t]
 * [^int_least32_t]
 * [^uint_least8_t]
 * [^uint_least16_t]
 * [^uint_least32_t]
 The following types are available only if, after including <boost/cstdint.hpp>, the macro BOOST_NO_INT64_T is not defined:
 * [^int_least64_t]
 * [^uint_least64_t]
 All other minimum-width integer types are optional.
 [endsect] 
 [section Fastest minimum-width integer types]
 The typedef [^int_fast#_t], with # replaced by the width, designates the fastest signed integer type 
 with a width of at least # bits. Similarly, the typedef name [^uint_fast#_t] designates the fastest 
 unsigned integer type with a width of at least # bits.
 There is no guarantee that these types are fastest for all purposes.  In any case, however, they satisfy  
 the signedness and width requirements.
 The following fastest minimum-width integer types are provided for all platforms:
 * [^int_fast8_t]
 * [^int_fast16_t]
 * [^int_fast32_t]
 * [^uint_fast8_t]
 * [^uint_fast16_t]
 * [^uint_fast32_t]
 The following types are available only if, after including <boost/cstdint.hpp>, the macro BOOST_NO_INT64_T is not defined:
 * [^int_fast64_t]
 * [^uint_fast64_t]
 All other fastest minimum-width integer types are optional.
 [endsect] 
 [section Greatest-width integer types]
 The typedef [^intmax_t ]designates a signed integer type capable of representing any value of any signed integer type.
 The typedef [^uintmax_t] designates an unsigned integer type capable of representing any value of any unsigned integer type.
 These types are provided for all platforms.
 [endsect]
 [section Integer Constant Macros]
 The following macros are always defined after inclusion of this header, these allow
 integer constants of at least the specified width to be declared:  
 INT8_C, UINT8_C, INT16_C, UINT16_C, INT32_C, UINT32_C, INTMAX_C, UINTMAX_C.
 The macros INT64_C and UINT64_C are also defined if the the macro BOOST_NO_INT64_T is not defined.
 The C99 macro __STDC_CONSTANT_MACROS is also defined as an artifact of the implementation.
 For example:
   #include <boost/cstdint.hpp>
   // Here the constant 0x1FFFFFFFF has the correct suffix applied:
   static const boost::uint64_t c = INT64_C(0x1FFFFFFFF); 
 [endsect]
 [endsect]
 [section:traits Integer Traits]
 [section Motivation]
 The C++ Standard Library <limits> header supplies a class template `numeric_limits<>` with specializations for each fundamental type.
 For integer types, the interesting members of `std::numeric_limits<>` are: 
   static const bool is_specialized;      // Will be true for integer types.
   static T min() throw();                // Smallest representable value.
   static T max() throw();                // Largest representable value.
   static const int digits;               // For integers, the number of value bits.
   static const int digits10;             // The number of base 10 digits that can be represented.
   static const bool is_signed;           // True if the type is signed.
   static const bool is_integer;          // Will be true for all integer types.
 For many uses, these are sufficient. 
 But min() and max() are problematical because they are not constant expressions (std::5.19), 
 yet some usages require constant expressions. 
 The template class [^integer_traits] addresses this problem. 
 [endsect] 
 [section Synopsis]
   namespace boost {
     template<class T>
     class integer_traits : public std::numeric_limits<T>
     {
     public:
        static const bool is_integral = false;
        //
        // These members are defined only if T is a built-in
        // integal type:
        //
        static const T const_min = ``['implementation-defined]``;
        static const T const_max = ``['implementation-defined]``;
     };
   }
 [endsect] 
 [section Description]
 Template class [^integer_traits] is derived from [^std::numeric_limits]. The primary specialization adds the single 
 [^bool] member [^is_integral] with the compile-time constant value [^false]. 
 However, for all integral types [^T] (std::3.9.1/7 [basic.fundamental]), there are specializations 
 provided with the following compile-time constants defined: 
 [table 
   [[member][type][value]]
   [[[^is_integral]][bool][[^true]]]
   [[[^const_min]][[^T]][equivalent to [^std::numeric_limits<T>::min()]]]
   [[[^const_max]][[^T]][equivalent to [^std::numeric_limits<T>::max()]]]
 ]
 Note: The /is_integral/ flag is provided, because a user-defined integer class should specialize 
 [^std::numeric_limits<>::is_integer = true], while compile-time constants 
 [^const_min] and [^const_max] are not provided for that user-defined class, unless boost::integer_traits is also specialized. 
 [endsect] 
 [section Test Program]
 The program [^[@../../test/integer_traits_test.cpp integer_traits_test.cpp]] exercises the [^integer_traits] class. 
 [endsect] 
 [section Acknowledgements]
 Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer traits idea on the boost mailing list in August 1999.
 [endsect]
 [endsect]
 [section:integer Integer Type Selection]
 The [@../../../../boost/integer.hpp <boost/integer.hpp>] type selection templates allow 
 integer types to be selected based on desired characteristics such as number of bits or maximum value. 
 This facility is particularly useful for solving generic programming problems.
 [section:synopsis Synopsis]
   namespace boost
   {
     //  fast integers from least integers
     template<typename LeastInt>
     struct int_fast_t
     {
         typedef ``['implementation-defined-type]``  type;
     };
     //  signed
     template<int Bits>
     struct int_t 
     {
         /* Member exact may or may not be defined depending upon Bits */
         typedef ``['implementation-defined-type]``  exact;
         typedef ``['implementation-defined-type]``  least;
         typedef int_fast_t<least>::fast      fast;
     };
     //  unsigned
     template<int Bits>
     struct uint_t 
     {
         /* Member exact may or may not be defined depending upon Bits */
         typedef ``['implementation-defined-type]``  exact;
         typedef ``['implementation-defined-type]``  least;
         typedef int_fast_t<least>::fast      fast;
     };
     //  signed
     template<long long MaxValue>
     struct int_max_value_t 
     {
         typedef ``['implementation-defined-type]``  least;
         typedef int_fast_t<least>::fast      fast;
     };
     template<long long MinValue>
     struct int_min_value_t 
     {
         typedef ``['implementation-defined-type]``  least;
         typedef int_fast_t<least>::fast      fast;
     };
     //  unsigned
     template<unsigned long long Value>
     struct uint_value_t 
     {
         typedef ``['implementation-defined-type]``  least;
         typedef int_fast_t<least>::fast      fast;
     };
   } // namespace boost
 [endsect]
 [section:easiest Easiest-to-Manipulate Types]
 The [^int_fast_t] class template maps its input type to the next-largest type that the processor 
 can manipulate the easiest, or to itself if the input type is already an easy-to-manipulate type. 
 For instance, processing a bunch of [^char] objects may go faster if they were converted to [^int] objects before processing. 
 The input type, passed as the only template parameter, must be a built-in integral type, except [^bool]. 
 Unsigned integral types can be used, as well as signed integral types. 
 The output type is given as the nested type [^fast].
 [*Implementation Notes:] 
 By default, the output type is identical to the input type. Eventually, this code's implementation should 
 be customized for each platform to give accurate mappings between the built-in types and the easiest-to-manipulate 
 built-in types. Also, there is no guarantee that the output type actually is easier to manipulate than the input type.
 [endsect]
 [section:sized Sized Types]
 The [^int_t], [^uint_t], [^int_max_value_t], [^int_min_value_t], and [^uint_value_t] class templates find 
 the most appropiate built-in integral type for the given template parameter. This type is given by the 
 nested type [^least]. The easiest-to-manipulate version of that type is given by the nested type [^fast]. 
 The following table describes each template's criteria.
 [table Criteria for the Sized Type Class Templates
   [
      [Class Template][Template Parameter Mapping]
   ]
   [
      [[^boost::int_t<N>::least]]
      [The smallest, built-in, signed integral type with at least /N/ bits, including the sign bit. 
      The parameter should be a positive number. A compile-time error results if the parameter is 
      larger than the number of bits in the largest integer type.]
   ]
   [
      [[^boost::int_t<N>::fast]]
      [The easiest-to-manipulate, built-in, signed integral type with at least /N/ bits, including the sign bit. 
      The parameter should be a positive number. A compile-time error results if the parameter is 
      larger than the number of bits in the largest integer type.]
   ]
   [
      [[^boost::int_t<N>::exact]]
      [A built-in, signed integral type with exactly /N/ bits, including the sign bit. 
      The parameter should be a positive number.  Note that the member /exact/ is defined
      [*only] if there exists a type with exactly /N/ bits.]
   ]
   [
      [[^boost::uint_t<N>::least]]
      [The smallest, built-in, unsigned integral type with at least /N/ bits. 
      The parameter should be a positive number. A compile-time error results if the 
      parameter is larger than the number of bits in the largest integer type.]
   ]
   [
      [[^boost::uint_t<N>::fast]]
      [The easiest-to-manipulate, built-in, unsigned integral type with at least /N/ bits. 
      The parameter should be a positive number. A compile-time error results if the 
      parameter is larger than the number of bits in the largest integer type.]
   ]
   [
      [[^boost::uint_t<N>::exact]]
      [A built-in, unsigned integral type with exactly /N/ bits. 
      The parameter should be a positive number. A compile-time error results if the 
      parameter is larger than the number of bits in the largest integer type.  
      Note that the member /exact/ is defined
      [*only] if there exists a type with exactly N bits.]
   ]
   [
      [[^boost::int_max_value_t<V>::last]]
      [The smallest, built-in, signed integral type that can hold all the values in the inclusive range ['0 - V]. 
      The parameter should be a positive number.]
   ]
   [
      [[^boost::int_max_value_t<V>::fast]]
      [The easiest-to-manipulate, built-in, signed integral type that can hold all the values in the inclusive range ['0 - V]. 
      The parameter should be a positive number.]
   ]
   [
      [[^boost::int_min_value_t<V>::least]]
      [The smallest, built-in, signed integral type that can hold all the values in the inclusive range ['V - 0]. 
      The parameter should be a negative number.]
   ]
   [
      [[^boost::int_min_value_t<V>::fast]]
      [The easiest-to-manipulate, built-in, signed integral type that can hold all the values in the inclusive range ['V - 0]. 
      The parameter should be a negative number.]
   ]
   [
      [[^boost::uint_value_t<V>::least]]
      [The smallest, built-in, unsigned integral type that can hold all positive values
      up to and including /V/. The parameter should be a positive number.]
   ]
   [
      [[^boost::uint_value_t<V>::fast]]
      [The easiest-to-manipulate, built-in, unsigned integral type that can hold all positive values
      up to and including /V/. The parameter should be a positive number.]
   ]
 ]
 [endsect]
 [section Example]
   #include <boost/integer.hpp>
   //...
   int main()
   {
       boost::int_t<24>::least my_var;  // my_var has at least 24-bits
       //...
       // This one is guarenteed not to be truncated:
       boost::int_max_value_t<1000>::least my1000 = 1000;
       //...
       // This one is guarenteed not to be truncated, and as fast
       // to manipulate as possible, its size may be greater than
       // that of my1000:
       boost::int_max_value_t<1000>::fast my_fast1000 = 1000;
   }
 [endsect]
 [section Demonstration Program]
 The program [@../../test/integer_test.cpp integer_test.cpp] is a simplistic demonstration of the results from instantiating 
 various examples of the sized type class templates.
 [endsect]
 [section Rationale]
 The rationale for the design of the templates in this header includes:
 * Avoid recursion because of concern about C++'s limited guaranteed recursion depth (17).
 * Avoid macros on general principles.
 * Try to keep the design as simple as possible.
 [endsect]
 [section Alternative]
 If the number of bits required is known beforehand, it may be more appropriate to use the types supplied 
 in [@../../../../boost/cstdint.hpp <boost/cstdint.hpp>].
 [endsect]
 [section Credits]
 The author of most of the Boost integer type choosing templates is 
 [@http://www.boost.org/people/beman_dawes.html Beman Dawes]. 
 He gives thanks to Valentin Bonnard and [@http://www.boost.org/people/kevlin_henney.htm Kevlin Henney] 
 for sharing their designs for similar templates. 
 [@http://www.boost.org/people/daryle_walker.html Daryle Walker] designed the value-based sized templates.
 [endsect]
 [endsect]
 [section:mask Integer Masks]
 [section Overview]
 The class templates in [@../../../../boost/integer/integer_mask.hpp <boost/integer/integer_mask.hpp>] 
 provide bit masks for a certain bit position or a contiguous-bit pack of a certain size. 
 The types of the masking constants come from the [link boost_integer.integer integer type selection templates] header.
 [endsect]
 [section Synopsis]
   #include <cstddef>  // for std::size_t
   namespace boost
   {
   template <std::size_t Bit>
   struct high_bit_mask_t
   {
       typedef ``['implementation-defined-type]``  least;
       typedef ``['implementation-defined-type]``  fast;
       static const least       high_bit       = ``['implementation-defined]``;
       static const fast        high_bit_fast  = ``['implementation-defined]``;
       static const std::size_t bit_position   = Bit;
   };
   template <std::size_t Bits>
   struct low_bits_mask_t
   {
       typedef ``['implementation-defined-type]``  least;
       typedef ``['implementation-defined-type]``  fast;
       static const least       sig_bits       = ``['implementation-defined]``;
       static const fast        sig_bits_fast  = ``['implementation-defined]``;
       static const std::size_t bit_count      = Bits;
   };
   // Specializations for low_bits_mask_t exist for certain bit counts.
   }  // namespace boost
 [endsect] 
 [section Single Bit-Mask Class Template]
 The [^boost::high_bit_mask_t] class template provides constants for bit masks representing the bit at a 
 certain position. The masks are equivalent to the value 2[super Bit], where [^Bit] is the template parameter. 
 The bit position must be a nonnegative number from zero to ['Max], where Max is one less than the 
 number of bits supported by the largest unsigned built-in integral type. The following table describes 
 the members of an instantiation of [^high_bit_mask_t].
 [table Members of the `boost::high_bit_mask_t` Class Template
   [[Member][Meaning]]
   [[[^least]][The smallest, unsigned, built-in type that supports the given bit position.]]
   [[[^fast]][The easiest-to-manipulate analog of [^least].]]
   [[[^high_bit]][A [^least] constant of the value 2[super Bit].]]
   [[[^high_bit_fast]][A [^fast] analog of [^high_bit].]]
   [[[^bit_position]][The value of the template parameter, in case its needed from a renamed instantiation of the class template.]]
 ]
 [endsect] 
 [section Group Bit-Mask Class Template]
 The [^boost::low_bits_mask_t] class template provides constants for bit masks 
 equivalent to the value (2[super Bits] - 1), where [^Bits] is the template parameter. 
 The parameter [^Bits] must be a non-negative integer from 
 zero to ['Max], where Max is the number of bits supported by the largest, unsigned, built-in integral type. 
 The following table describes the members of [^low_bits_mask_t].
 [table Members of the [^boost::low_bits_mask_t] Class Template
 [[Member][Meaning]]
 [[[^least]][The smallest, unsigned built-in type that supports the given bit count.]]
 [[[^fast]][The easiest-to-manipulate analog of [^least].]]
 [[[^sig_bits]][A [^least] constant of the desired bit-masking value.]]
 [[[^sig_bits_fast]][A [^fast] analog of [^sig_bits].]]
 [[[^bit_count]][The value of the template parameter, in case its needed from a renamed instantiation of the class template.]]
 ]
 [endsect]
 [section Implementation Notes]
 When [^Bits] is the exact size of a built-in unsigned type, the implementation has to change to 
 prevent undefined behavior. Therefore, there are specializations of [^low_bits_mask_t] at those bit counts.
 [endsect]
 [section Example]
   #include <boost/integer/integer_mask.hpp>
   //...
   int main()
   {
       typedef boost::high_bit_mask_t<29>  mask1_type;
       typedef boost::low_bits_mask_t<15>  mask2_type;
       mask1_type::least  my_var1;
       mask2_type::fast   my_var2;
       //...
       my_var1 |= mask1_type::high_bit;
       my_var2 &= mask2_type::sig_bits_fast;
       //...
   }
 [endsect] 
 [section Demonstration Program]
 The program [@../../test/integer_mask_test.cpp integer_mask_test.cpp] is a simplistic demonstration of the 
 results from instantiating various examples of the bit mask class templates.
 [endsect] 
 [section Rationale]
 The class templates in this header are an extension of the [link boost_integer.integer integer type selection class templates]. 
 The new class templates provide the same sized types, but also convenient masks to use when extracting the 
 highest or all the significant bits when the containing built-in type contains more bits. 
 This prevents contamination of values by the higher, unused bits.
 [endsect] 
 [section Credits]
 The author of the Boost bit mask class templates is [@http://www.boost.org/people/daryle_walker.html Daryle Walker].
 [endsect]
 [endsect]
 [section:log2 Compile Time log2 Calculation]
 The class template in [@../../../../boost/integer/static_log2.hpp <boost/integer/static_log2.hpp>] 
 determines the position of the highest bit in a given value. This facility is useful for solving generic programming problems.
 [section Synopsis]
   namespace boost
   {
     typedef ``['implementation-defined]`` static_log2_argument_type;
     typedef ``['implementation-defined]`` static_log2_result_type;
     template <static_log2_argument_type arg>
     struct static_log2
     {
       static const static_log2_result_type value = ``['implementation-defined]``;
     };
     template < >
     struct static_log2< 0 >
     {
       // The logarithm of zero is undefined.
     };
   }  // namespace boost
 [endsect] 
 [section Usage]
 The [^boost::static_log2] class template takes one template parameter, a value of type 
 [^static_log2_argument_type]. The template only defines one member, [^value], which gives the 
 truncated, base-two logarithm of the template argument.
 Since the logarithm of zero, for any base, is undefined, there is a specialization of [^static_log2] 
 for a template argument of zero. This specialization has no members, so an attempt to use the base-two 
 logarithm of zero results in a compile-time error.
 Note: 
 * [^static_log2_argument_type] is an ['unsigned integer type] (C++ standard, 3.9.1p3).
 * [^static_log2_result_type] is an ['integer type] (C++ standard, 3.9.1p7).
 [endsect] 
 [section Demonstration Program]
 The program [@../../test/static_log2_test.cpp static_log2_test.cpp] is a simplistic 
 demonstration of the results from instantiating various examples of the binary logarithm class template.
 [endsect]
 [section Rationale]
 The base-two (binary) logarithm, abbreviated lb, function 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 available statically (['i.e.] at compile-time).
 [endsect] 
 [section Credits]
 The original version of the Boost binary logarithm class template was 
 written by [@http://www.boost.org/people/daryle_walker.html Daryle Walker] 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.
 [endsect]
 [endsect]
 [section:minmax Compile time min/max calculation]
 The class templates in [@../../../../boost/integer/static_min_max.hpp <boost/integer/static_min_max.hpp>] 
 provide a compile-time evaluation of the minimum or maximum of two integers. These facilities are useful 
 for generic programming problems.
 [section Synopsis]
   namespace boost
   {
   typedef ``['implementation-defined]`` static_min_max_signed_type;
   typedef ``['implementation-defined]`` static_min_max_unsigned_type;
   template <static_min_max_signed_type Value1, static_min_max_signed_type Value2 >
       struct static_signed_min;
   template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
       struct static_signed_max;
   template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
       struct static_unsigned_min;
   template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
       struct static_unsigned_max;
   }
 [endsect] 
 [section Usage]
 The four class templates provide the combinations for finding the minimum or maximum of two [^signed] or 
 [^unsigned] ([^long]) parameters, /Value1/ and /Value2/, at compile-time. Each template has a single static data member, 
 [^value], which is set to the respective minimum or maximum of the template's parameters.
 [endsect] 
 [section Example]
   #include <boost/integer/static_min_max.hpp>
   template < unsigned long AddendSize1, unsigned long AddendSize2 >
   class adder
   {
   public:
       static  unsigned long  const  addend1_size = AddendSize1;
       static  unsigned long  const  addend2_size = AddendSize2;
       static  unsigned long  const  sum_size = boost::static_unsigned_max<AddendSize1, AddendSize2>::value + 1;
       typedef int  addend1_type[ addend1_size ];
       typedef int  addend2_type[ addend2_size ];
       typedef int  sum_type[ sum_size ];
       void  operator ()( addend1_type const &a1, addend2_type const &a2, sum_type &s ) const;
   };
   //...
   int main()
   {
       int const   a1[] = { 0, 4, 3 };  // 340
       int const   a2[] = { 9, 8 };     //  89
       int         s[ 4 ];
       adder<3,2>  obj;
       obj( a1, a2, s );  // 's' should be 429 or { 9, 2, 4, 0 }
       //...
   }
 [endsect]
 [section Demonstration Program]
 The program [@../../test/static_min_max_test.cpp static_min_max_test.cpp] is a simplistic demonstration of 
 various comparisons using the compile-time extrema class templates.
 [endsect] 
 [section Rationale]
 Sometimes the minimum or maximum of several values needs to be found for later compile-time processing, 
 ['e.g.] for a bound for another class template.
 [endsect]
 [section Credits]
 The author of the Boost compile-time extrema class templates is [@http://www.boost.org/people/daryle_walker.html Daryle Walker].
 [endsect]
 [endsect]
 [section:history History]
 [h4 1.42.0]
 * Reverted Trunk to release branch state (i.e. a "known good state").
 * Fixed issues: [@https://svn.boost.org/trac/boost/ticket/653 653], 
 [@https://svn.boost.org/trac/boost/ticket/3084 3084], 
 [@https://svn.boost.org/trac/boost/ticket/3177 3177], 
 [@https://svn.boost.org/trac/boost/ticket/3180 3180], 
 [@https://svn.boost.org/trac/boost/ticket/3548 3568], 
 [@https://svn.boost.org/trac/boost/ticket/3657 3657], 
 [@https://svn.boost.org/trac/boost/ticket/2134 2134].
 * Added long long support to [^boost::static_log2], [^boost::static_signed_min], [^boost::static_signed_max], 
 [^boost::static_unsigned_min][^boost::static_unsigned_max], when available.
 * The argument type and the result type of [^boost::static_signed_min] etc are now typedef'd. 
 Formerly, they were hardcoded as [^unsigned long] and [^int] respectively. Please, use the 
 provided typedefs in new code (and update old code as soon as possible).
 [h4 1.32.0]
 * The argument type and the result type of [^boost::static_log2] are now typedef'd. 
 Formerly, they were hardcoded as [^unsigned long] and [^int] respectively. Please, use the 
 provided typedefs in new code (and update old code as soon as possible).
 [endsect]
--- a/include/boost/cstdint.hpp
+++ b/include/boost/cstdint.hpp
@ -1,14 +1,16 @@
 //  boost cstdint.hpp header file  ------------------------------------------//
-//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
+//  (C) Copyright Beman Dawes 1999. 
-//  and distribute this software is granted provided this copyright
+//  (C) Copyright Jens Mauer 2001  
-//  notice appears in all copies. This software is provided "as is" without
+//  (C) Copyright John Maddock 2001 
-//  express or implied warranty, and with no claim as to its suitability for
+//  Distributed under the Boost
-//  any purpose.
+//  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 for most recent version including documentation.
+//  See http://www.boost.org/libs/integer for documentation.
 //  Revision History
 //   31 Oct 01  use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.)
 //   16 Apr 01  check LONGLONG_MAX when looking for "long long" (Jens Maurer)
 //   23 Jan 01  prefer "long" over "int" for int32_t and intmax_t (Jens Maurer)
 //   12 Nov 00  Merged <boost/stdint.h> (Jens Maurer)
@ -21,23 +23,80 @@
 #ifndef BOOST_CSTDINT_HPP
 #define BOOST_CSTDINT_HPP
 //
 // Since we always define the INT#_C macros as per C++0x, 
 // define __STDC_CONSTANT_MACROS so that <stdint.h> does the right
 // thing if possible, and so that the user knows that the macros 
 // are actually defined as per C99.
 //
 #ifndef __STDC_CONSTANT_MACROS
 #  define __STDC_CONSTANT_MACROS
 #endif
 #include <boost/config.hpp>
-
+//
-#ifdef BOOST_SYSTEM_HAS_STDINT_H
+// Note that GLIBC is a bit inconsistent about whether int64_t is defined or not
 // depending upon what headers happen to have been included first...
 // so we disable use of stdint.h when GLIBC does not define __GLIBC_HAVE_LONG_LONG.
 // See https://svn.boost.org/trac/boost/ticket/3548 and http://sources.redhat.com/bugzilla/show_bug.cgi?id=10990
 //
 #if defined(BOOST_HAS_STDINT_H) && (!defined(__GLIBC__) || defined(__GLIBC_HAVE_LONG_LONG))
 // The following #include is an implementation artifact; not part of interface.
 # ifdef __hpux
-// HP-UX has a nice <stdint.h> in a non-standard location
+// HP-UX has a vaguely nice <stdint.h> in a non-standard location
-#   include <sys/_inttypes.h>
+#   include <inttypes.h>
 #   ifdef __STDC_32_MODE__
      // this is triggered with GCC, because it defines __cplusplus < 199707L
 #     define BOOST_NO_INT64_T
 #   endif 
 # elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX)
 #   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
 {
@ -78,11 +137,58 @@ namespace boost
 } // namespace boost
 #elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS)
 // FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
 # include <inttypes.h>
-#else  // BOOST_SYSTEM_HAS_STDINT_H
+namespace boost {
  using ::int8_t;             
  typedef int8_t int_least8_t;       
  typedef int8_t int_fast8_t;        
  using ::uint8_t;            
  typedef uint8_t uint_least8_t;      
  typedef uint8_t uint_fast8_t;       
  using ::int16_t;            
  typedef int16_t int_least16_t;      
  typedef int16_t int_fast16_t;       
  using ::uint16_t;           
  typedef uint16_t uint_least16_t;     
  typedef uint16_t uint_fast16_t;      
  using ::int32_t;            
  typedef int32_t int_least32_t;      
  typedef int32_t int_fast32_t;       
  using ::uint32_t;           
  typedef uint32_t uint_least32_t;     
  typedef uint32_t uint_fast32_t;      
 # ifndef BOOST_NO_INT64_T          
-# include <limits.h> // implementation artifact; not part of interface
+  using ::int64_t;            
  typedef int64_t int_least64_t;      
  typedef int64_t int_fast64_t;       
  using ::uint64_t;           
  typedef uint64_t uint_least64_t;     
  typedef uint64_t uint_fast64_t;      
  typedef int64_t intmax_t;
  typedef uint64_t uintmax_t;
 # else
  typedef int32_t intmax_t;
  typedef uint32_t uintmax_t;
 # endif
 } // namespace boost
 #else  // BOOST_HAS_STDINT_H
 # include <boost/limits.hpp> // implementation artifact; not part of interface
 # include <limits.h>         // needed for limits macros
 namespace boost
@ -112,54 +218,100 @@ 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(__MTA__) 
      // On MTA / XMT short is 32 bits unless the -short16 compiler flag is specified 
      // MTA / XMT does support the following non-standard integer types 
      typedef __short16           int16_t; 
      typedef __short16           int_least16_t; 
      typedef __short16           int_fast16_t; 
      typedef unsigned __short16  uint16_t; 
      typedef unsigned __short16  uint_least16_t; 
      typedef unsigned __short16  uint_fast16_t; 
 # 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
 //  32-bit types  -----------------------------------------------------------//
-# if ULONG_MAX == 0xffffffff
+# if UINT_MAX == 0xffffffff
     typedef long            int32_t;
     typedef long            int_least32_t;
     typedef long            int_fast32_t;
     typedef unsigned long   uint32_t;
     typedef unsigned long   uint_least32_t;
     typedef unsigned long   uint_fast32_t;
 # elif UINT_MAX == 0xffffffff
     typedef int             int32_t;
     typedef int             int_least32_t;
     typedef int             int_fast32_t;
     typedef unsigned int    uint32_t;
     typedef unsigned int    uint_least32_t;
     typedef unsigned int    uint_fast32_t;
 # elif (USHRT_MAX == 0xffffffff)
     typedef short             int32_t;
     typedef short             int_least32_t;
     typedef short             int_fast32_t;
     typedef unsigned short    uint32_t;
     typedef unsigned short    uint_least32_t;
     typedef unsigned short    uint_fast32_t;
 # elif ULONG_MAX == 0xffffffff
     typedef long            int32_t;
     typedef long            int_least32_t;
     typedef long            int_fast32_t;
     typedef unsigned long   uint32_t;
     typedef unsigned long   uint_least32_t;
     typedef unsigned long   uint_fast32_t;
 # elif (UINT_MAX == 0xffffffffffffffff) && defined(__MTA__) 
      // Integers are 64 bits on the MTA / XMT 
      typedef __int32           int32_t; 
      typedef __int32           int_least32_t; 
      typedef __int32           int_fast32_t; 
      typedef unsigned __int32  uint32_t; 
      typedef unsigned __int32  uint_least32_t; 
      typedef unsigned __int32  uint_fast32_t; 
 # else
 #    error defaults not correct; you must hand modify boost/cstdint.hpp
 # endif
 //  64-bit types + intmax_t and uintmax_t  ----------------------------------//
-# if !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \
+# if defined(BOOST_HAS_LONG_LONG) && \
   !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \
   (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
   (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
-#    if (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615U) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615U) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615U)
+#    if defined(__hpux)
     // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
 #    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL)
                                                                 // 2**64 - 1
     typedef long long            intmax_t;
     typedef unsigned long long   uintmax_t;
     typedef long long            int64_t;
     typedef long long            int_least64_t;
     typedef long long            int_fast64_t;
     typedef unsigned long long   uint64_t;
     typedef unsigned long long   uint_least64_t;
     typedef unsigned long long   uint_fast64_t;
 #    else
 #       error defaults not correct; you must hand modify boost/cstdint.hpp
 #    endif
     typedef  ::boost::long_long_type            intmax_t;
     typedef  ::boost::ulong_long_type   uintmax_t;
     typedef  ::boost::long_long_type            int64_t;
     typedef  ::boost::long_long_type            int_least64_t;
     typedef  ::boost::long_long_type            int_fast64_t;
     typedef  ::boost::ulong_long_type   uint64_t;
     typedef  ::boost::ulong_long_type   uint_least64_t;
     typedef  ::boost::ulong_long_type   uint_fast64_t;
 # elif ULONG_MAX != 0xffffffff
 #    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
@ -174,9 +326,18 @@ namespace boost
 #    else
 #       error defaults not correct; you must hand modify boost/cstdint.hpp
 #    endif
-# elif (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520))
+# 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/Microsoft __int64:
+     // we have Borland/Intel/Microsoft __int64:
     //
     typedef __int64             intmax_t;
     typedef unsigned __int64    uintmax_t;
@ -195,7 +356,7 @@ namespace boost
 } // namespace boost
-#endif // BOOST_SYSTEM_HAS_STDINT_H
+#endif // BOOST_HAS_STDINT_H
 #endif // BOOST_CSTDINT_HPP
@ -204,72 +365,107 @@ namespace boost
 Macro definition section:
-Define various INTXX_C macros only if
+Added 23rd September 2000 (John Maddock).
-__STDC_CONSTANT_MACROS is defined.
+Modified 11th September 2001 to be excluded when
-
+BOOST_HAS_STDINT_H is defined (John Maddock).
-Undefine the macros if __STDC_CONSTANT_MACROS is
+Modified 11th Dec 2009 to always define the
-not defined and the macros are (cf <cassert>).
+INT#_C macros if they're not already defined (John Maddock).
 Added 23rd September (John Maddock).
 ******************************************************/
-#if defined(__STDC_CONSTANT_MACROS) && !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED)
+#if !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && \
   (!defined(INT8_C) || !defined(INT16_C) || !defined(INT32_C) || !defined(INT64_C))
 //
 // For the following code we get several warnings along the lines of: 
 // 
 // boost/cstdint.hpp:428:35: error: use of C99 long long integer constant 
 // 
 // So we declare this a system header to suppress these warnings. 
 //
 #if defined(__GNUC__) && (__GNUC__ >= 4) 
 #pragma GCC system_header 
 #endif 
 #include <limits.h>
 # define BOOST__STDC_CONSTANT_MACROS_DEFINED
-# if (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520))
+# if defined(BOOST_HAS_MS_INT64)
 //
-// Borland/Microsoft compilers have width specific suffixes:
+// Borland/Intel/Microsoft compilers have width specific suffixes:
 //
 #ifndef INT8_C
 #  define INT8_C(value)     value##i8
 #endif
 #ifndef INT16_C
 #  define INT16_C(value)    value##i16
 #endif
 #ifndef INT32_C
 #  define INT32_C(value)    value##i32
 #endif
 #ifndef INT64_C
 #  define INT64_C(value)    value##i64
 #endif
 #  ifdef __BORLANDC__
    // Borland bug: appending ui8 makes the type a signed char
 #   define UINT8_C(value)    static_cast<unsigned char>(value##u)
 #  else
 #   define UINT8_C(value)    value##ui8
 #  endif
 #ifndef UINT16_C
 #  define UINT16_C(value)   value##ui16
 #endif
 #ifndef UINT32_C
 #  define UINT32_C(value)   value##ui32
 #endif
 #ifndef UINT64_C
 #  define UINT64_C(value)   value##ui64
 #endif
 #ifndef INTMAX_C
 #  define INTMAX_C(value)   value##i64
 #  define UINTMAX_C(value)  value##ui64
 #endif
 # else
 //  do it the old fashioned way:
 //  8-bit types  ------------------------------------------------------------//
-#  if UCHAR_MAX == 0xff
+#  if (UCHAR_MAX == 0xff) && !defined(INT8_C)
 #   define INT8_C(value) static_cast<boost::int8_t>(value)
 #   define UINT8_C(value) static_cast<boost::uint8_t>(value##u)
 #  endif
 //  16-bit types  -----------------------------------------------------------//
-#  if USHRT_MAX == 0xffff
+#  if (USHRT_MAX == 0xffff) && !defined(INT16_C)
 #   define INT16_C(value) static_cast<boost::int16_t>(value)
 #   define UINT16_C(value) static_cast<boost::uint16_t>(value##u)
 #  endif
 //  32-bit types  -----------------------------------------------------------//
-
+#ifndef INT32_C
-#  if UINT_MAX == 0xffffffff
+#  if (UINT_MAX == 0xffffffff)
 #   define INT32_C(value) value
 #   define UINT32_C(value) value##u
 #  elif ULONG_MAX == 0xffffffff
 #   define INT32_C(value) value##L
 #   define UINT32_C(value) value##uL
 #  endif
 #endif
 //  64-bit types + intmax_t and uintmax_t  ----------------------------------//
 #ifndef INT64_C
 #  if defined(BOOST_HAS_LONG_LONG) && \
    (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX) || defined(_LLONG_MAX))
 #    if defined(__hpux)
        // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
 #       define INT64_C(value) value##LL
 #       define UINT64_C(value) value##uLL
 #    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) ||  \
        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) ||  \
        (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) || \
        (defined(_LLONG_MAX) && _LLONG_MAX == 18446744073709551615ULL)
 #  if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)
     // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
 #    if (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615U) ||  \
        (defined(ULONG_LONG_MAX) && (defined(__hpux) || ULONG_LONG_MAX == 18446744073709551615U)) ||  \
        (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615U)
 #       define INT64_C(value) value##LL
 #       define UINT64_C(value) value##uLL
 #    else
@ -277,12 +473,22 @@ Added 23rd September (John Maddock).
 #    endif
 #  elif ULONG_MAX != 0xffffffff
-#    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
+#    if ULONG_MAX == 18446744073709551615U // 2**64 - 1
 #       define INT64_C(value) value##L
 #       define UINT64_C(value) value##uL
 #    else
 #       error defaults not correct; you must hand modify boost/cstdint.hpp
 #    endif
 #  elif defined(BOOST_HAS_LONG_LONG)
     // Usual macros not defined, work things out for ourselves:
 #    if(~0uLL == 18446744073709551615ULL)
 #       define INT64_C(value) value##LL
 #       define UINT64_C(value) value##uLL
 #    else
 #       error defaults not correct; you must hand modify boost/cstdint.hpp
 #    endif
 #  else
 #    error defaults not correct; you must hand modify boost/cstdint.hpp
 #  endif
 #  ifdef BOOST_NO_INT64_T
@ -292,25 +498,11 @@ Added 23rd September (John Maddock).
 #   define INTMAX_C(value) INT64_C(value)
 #   define UINTMAX_C(value) UINT64_C(value)
 #  endif
-
+#endif
 # endif // Borland/Microsoft specific width suffixes
-
+#endif // INT#_C macros.
-#elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS)
+
-//
+
 // undef all the macros:
 //
 # undef INT8_C
 # undef INT16_C
 # undef INT32_C
 # undef INT64_C
 # undef UINT8_C
 # undef UINT16_C
 # undef UINT32_C
 # undef UINT64_C
 # undef INTMAX_C
 # undef UINTMAX_C
 #endif // __STDC_CONSTANT_MACROS_DEFINED etc.
--- a/include/boost/integer.hpp
+++ b/include/boost/integer.hpp
@ -1,14 +1,13 @@
 //  boost integer.hpp header file  -------------------------------------------//
-//  (C) Copyright Beman Dawes 1999. Permission to copy, use, modify, sell
+//  Copyright Beman Dawes and Daryle Walker 1999.  Distributed under the Boost
-//  and distribute this software is granted provided this copyright
+//  Software License, Version 1.0. (See accompanying file
-//  notice appears in all copies. This software is provided "as is" without
+//  LICENSE_1_0.txt or copy at 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.
+//  See http://www.boost.org/libs/integer for documentation.
 //  Revision History
 //   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)
 //   28 Aug 99  Initial version
@ -16,7 +15,23 @@
 #ifndef BOOST_INTEGER_HPP
 #define BOOST_INTEGER_HPP
-#include <boost/limits.hpp>
+#include <boost/integer_fwd.hpp>  // self include
 #include <boost/integer_traits.hpp>  // for boost::::boost::integer_traits
 #include <boost/limits.hpp>          // for ::std::numeric_limits
 #include <boost/cstdint.hpp>         // for boost::int64_t and BOOST_NO_INTEGRAL_INT64_T
 //
 // We simply cannot include this header on gcc without getting copious warnings of the kind:
 //
 // boost/integer.hpp:77:30: warning: use of C99 long long integer constant
 //
 // And yet there is no other reasonable implementation, so we declare this a system header
 // to suppress these warnings.
 //
 #if defined(__GNUC__) && (__GNUC__ >= 4)
 #pragma GCC system_header
 #endif
 namespace boost
 {
@ -26,60 +41,217 @@ namespace boost
  //  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 LeastInt fast; }; // imps may specialize
+  struct int_fast_t 
  { 
     typedef LeastInt fast; 
     typedef fast     type;
  }; // imps may specialize
  namespace detail{
  //  convert category to type 
  template< int Category > struct int_least_helper {}; // default is empty
  //  specializatons: 1=long, 2=int, 3=short, 4=signed char,
-  //     6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned long
+  //     6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned char
  //  no specializations for 0 and 5: requests for a type > long are in error
-  template<> struct int_least_helper<1> { typedef long least; };
+#ifdef BOOST_HAS_LONG_LONG
-  template<> struct int_least_helper<2> { typedef int least; };
+  template<> struct int_least_helper<1> { typedef boost::long_long_type least; };
-  template<> struct int_least_helper<3> { typedef short least; };
+#elif defined(BOOST_HAS_MS_INT64)
-  template<> struct int_least_helper<4> { typedef signed char least; };
+  template<> struct int_least_helper<1> { typedef __int64 least; };
-  template<> struct int_least_helper<6> { typedef unsigned long least; };
+#endif
-  template<> struct int_least_helper<7> { typedef unsigned int least; };
+  template<> struct int_least_helper<2> { typedef long least; };
-  template<> struct int_least_helper<8> { typedef unsigned short least; };
+  template<> struct int_least_helper<3> { typedef int least; };
-  template<> struct int_least_helper<9> { typedef unsigned char least; };
+  template<> struct int_least_helper<4> { typedef short least; };
  template<> struct int_least_helper<5> { typedef signed char least; };
 #ifdef BOOST_HAS_LONG_LONG
  template<> struct int_least_helper<6> { typedef boost::ulong_long_type least; };
 #elif defined(BOOST_HAS_MS_INT64)
  template<> struct int_least_helper<6> { typedef unsigned __int64 least; };
 #endif
  template<> struct int_least_helper<7> { typedef unsigned long least; };
  template<> struct int_least_helper<8> { typedef unsigned int least; };
  template<> struct int_least_helper<9> { typedef unsigned short least; };
  template<> struct int_least_helper<10> { typedef unsigned char least; };
  template <int Bits>
  struct exact_signed_base_helper{};
  template <int Bits>
  struct exact_unsigned_base_helper{};
  template <> struct exact_signed_base_helper<sizeof(signed char)* CHAR_BIT> { typedef signed char exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned char)* CHAR_BIT> { typedef unsigned char exact; };
 #if USHRT_MAX != UCHAR_MAX
  template <> struct exact_signed_base_helper<sizeof(short)* CHAR_BIT> { typedef short exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned short)* CHAR_BIT> { typedef unsigned short exact; };
 #endif
 #if UINT_MAX != USHRT_MAX
  template <> struct exact_signed_base_helper<sizeof(int)* CHAR_BIT> { typedef int exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* CHAR_BIT> { typedef unsigned int exact; };
 #endif
 #if ULONG_MAX != UINT_MAX
  template <> struct exact_signed_base_helper<sizeof(long)* CHAR_BIT> { typedef long exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* CHAR_BIT> { typedef unsigned long exact; };
 #endif
 #if defined(BOOST_HAS_LONG_LONG) &&\
   ((defined(ULLONG_MAX) && (ULLONG_MAX != ULONG_MAX)) ||\
    (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX != ULONG_MAX)) ||\
    (defined(ULONGLONG_MAX) && (ULONGLONG_MAX != ULONG_MAX)) ||\
    (defined(_ULLONG_MAX) && (_ULLONG_MAX != ULONG_MAX)))
  template <> struct exact_signed_base_helper<sizeof(boost::long_long_type)* CHAR_BIT> { typedef boost::long_long_type exact; };
  template <> struct exact_unsigned_base_helper<sizeof(boost::ulong_long_type)* CHAR_BIT> { typedef boost::ulong_long_type exact; };
 #endif
  } // namespace detail
  //  integer templates specifying number of bits  ---------------------------//
  //  signed
  template< int Bits >   // bits (including sign) required
-  struct int_t 
+  struct int_t : public detail::exact_signed_base_helper<Bits>
  {
-      typedef typename int_least_helper
+      typedef typename detail::int_least_helper
        <
-          (Bits-1 <= std::numeric_limits<long>::digits) +
+#ifdef BOOST_HAS_LONG_LONG
-          (Bits-1 <= std::numeric_limits<int>::digits) +
+          (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
-          (Bits-1 <= std::numeric_limits<short>::digits) +
+#else
-          (Bits-1 <= std::numeric_limits<signed char>::digits)
+           1 +
 #endif
          (Bits-1 <= ::std::numeric_limits<long>::digits) +
          (Bits-1 <= ::std::numeric_limits<int>::digits) +
          (Bits-1 <= ::std::numeric_limits<short>::digits) +
          (Bits-1 <= ::std::numeric_limits<signed char>::digits)
        >::least  least;
-      typedef typename int_fast_t<least>::fast  fast;
+      typedef typename int_fast_t<least>::type  fast;
  };
  //  unsigned
  template< int Bits >   // bits required
-  struct uint_t 
+  struct uint_t : public detail::exact_unsigned_base_helper<Bits>
  {
-      typedef typename int_least_helper
+#if (defined(__BORLANDC__) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T)
     // It's really not clear why this workaround should be needed... shrug I guess!  JM
     BOOST_STATIC_CONSTANT(int, s = 
           6 +
          (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));
     typedef typename detail::int_least_helper< ::boost::uint_t<Bits>::s>::least least;
 #else
      typedef typename detail::int_least_helper
        < 
          5 +
-          (Bits <= std::numeric_limits<unsigned long>::digits) +
+#ifdef BOOST_HAS_LONG_LONG
-          (Bits <= std::numeric_limits<unsigned int>::digits) +
+          (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
-          (Bits <= std::numeric_limits<unsigned short>::digits) +
+#else
-          (Bits <= std::numeric_limits<unsigned char>::digits)
+           1 +
 #endif
          (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;
+#endif
      typedef typename int_fast_t<least>::type  fast;
      // int_fast_t<> works correctly for unsigned too, in spite of the name.
  };
-//  The same dispatching technique can be used to select types based on
+  //  integer templates specifying extreme value  ----------------------------//
-//  values.  That will be added once boost::integer_traits is available.
+
  //  signed
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
  template< boost::long_long_type MaxValue >   // maximum value to require support
 #else
  template< long MaxValue >   // maximum value to require support
 #endif
  struct int_max_value_t 
  {
      typedef typename detail::int_least_helper
        <
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
          (MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +
 #else
           1 +
 #endif
          (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)
        >::least  least;
      typedef typename int_fast_t<least>::type  fast;
  };
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
  template< boost::long_long_type MinValue >   // minimum value to require support
 #else
  template< long MinValue >   // minimum value to require support
 #endif
  struct int_min_value_t 
  {
      typedef typename detail::int_least_helper
        <
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
          (MinValue >= ::boost::integer_traits<boost::long_long_type>::const_min) +
 #else
           1 +
 #endif
          (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)
        >::least  least;
      typedef typename int_fast_t<least>::type  fast;
  };
  //  unsigned
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
  template< boost::ulong_long_type MaxValue >   // minimum value to require support
 #else
  template< unsigned long MaxValue >   // minimum value to require support
 #endif
  struct uint_value_t 
  {
 #if (defined(__BORLANDC__) || defined(__CODEGEAR__))
     // It's really not clear why this workaround should be needed... shrug I guess!  JM
 #if defined(BOOST_NO_INTEGRAL_INT64_T)
      BOOST_STATIC_CONSTANT(unsigned, which = 
           6 +
          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max));
      typedef typename detail::int_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
 #else // BOOST_NO_INTEGRAL_INT64_T
      BOOST_STATIC_CONSTANT(unsigned, which = 
           5 +
          (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max));
      typedef typename detail::int_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
 #endif // BOOST_NO_INTEGRAL_INT64_T
 #else
      typedef typename detail::int_least_helper
        < 
          5 +
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
          (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
 #else
           1 +
 #endif
          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max)
        >::least  least;
 #endif
      typedef typename int_fast_t<least>::type  fast;
  };
 } // namespace boost
 #endif  // BOOST_INTEGER_HPP
--- a/include/boost/integer/integer_mask.hpp
+++ b/include/boost/integer/integer_mask.hpp
@ -0,0 +1,126 @@
 //  Boost integer/integer_mask.hpp header file  ------------------------------//
 //  (C) Copyright Daryle Walker 2001.
 //  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 for updates, documentation, and revision history. 
 #ifndef BOOST_INTEGER_INTEGER_MASK_HPP
 #define BOOST_INTEGER_INTEGER_MASK_HPP
 #include <boost/integer_fwd.hpp>  // self include
 #include <boost/config.hpp>   // for BOOST_STATIC_CONSTANT
 #include <boost/integer.hpp>  // for boost::uint_t
 #include <climits>  // for UCHAR_MAX, etc.
 #include <cstddef>  // for std::size_t
 #include <boost/limits.hpp>  // for std::numeric_limits
 //
 // We simply cannot include this header on gcc without getting copious warnings of the kind:
 //
 // boost/integer/integer_mask.hpp:93:35: warning: use of C99 long long integer constant
 //
 // And yet there is no other reasonable implementation, so we declare this a system header
 // to suppress these warnings.
 //
 #if defined(__GNUC__) && (__GNUC__ >= 4)
 #pragma GCC system_header
 #endif
 namespace boost
 {
 //  Specified single-bit mask class declaration  -----------------------------//
 //  (Lowest bit starts counting at 0.)
 template < std::size_t Bit >
 struct high_bit_mask_t
 {
    typedef typename uint_t<(Bit + 1)>::least  least;
    typedef typename uint_t<(Bit + 1)>::fast   fast;
    BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << Bit) );
    BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << Bit) );
    BOOST_STATIC_CONSTANT( std::size_t, bit_position = Bit );
 };  // boost::high_bit_mask_t
 //  Specified bit-block mask class declaration  ------------------------------//
 //  Makes masks for the lowest N bits
 //  (Specializations are needed when N fills up a type.)
 template < std::size_t Bits >
 struct low_bits_mask_t
 {
    typedef typename uint_t<Bits>::least  least;
    typedef typename uint_t<Bits>::fast   fast;
    BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
    BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
 };  // boost::low_bits_mask_t
 #define BOOST_LOW_BITS_MASK_SPECIALIZE( Type )                                  \
  template <  >  struct low_bits_mask_t< std::numeric_limits<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 );    \
  }
 #ifdef BOOST_MSVC
 #pragma warning(push)
 #pragma warning(disable:4245)  // 'initializing' : conversion from 'int' to 'const boost::low_bits_mask_t<8>::least', signed/unsigned mismatch
 #endif
 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
 #if defined(BOOST_HAS_LONG_LONG)
    #if ((defined(ULLONG_MAX) && (ULLONG_MAX > ULONG_MAX)) ||\
        (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX > ULONG_MAX)) ||\
        (defined(ULONGLONG_MAX) && (ULONGLONG_MAX > ULONG_MAX)) ||\
        (defined(_ULLONG_MAX) && (_ULLONG_MAX > ULONG_MAX)))
    BOOST_LOW_BITS_MASK_SPECIALIZE( boost::ulong_long_type );
    #endif
 #elif defined(BOOST_HAS_MS_INT64)
    #if 18446744073709551615ui64 > ULONG_MAX
    BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned __int64 );
    #endif
 #endif
 #ifdef BOOST_MSVC
 #pragma warning(pop)
 #endif
 #undef BOOST_LOW_BITS_MASK_SPECIALIZE
 }  // namespace boost
 #endif  // BOOST_INTEGER_INTEGER_MASK_HPP
--- a/include/boost/integer/static_log2.hpp
+++ b/include/boost/integer/static_log2.hpp
@ -0,0 +1,127 @@
 // -------------- Boost 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.
 // ------------------------------------------------------------------------- //
 #ifndef BOOST_INTEGER_STATIC_LOG2_HPP
 #define BOOST_INTEGER_STATIC_LOG2_HPP
 #include "boost/integer_fwd.hpp" // for boost::intmax_t
 namespace boost {
 namespace detail {
     namespace static_log2_impl {
     // 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 boost::static_log2_argument_type argument_type;
     typedef boost::static_log2_result_type result_type;
     template <result_type n>
     struct choose_initial_n {
         BOOST_STATIC_CONSTANT(bool, 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);
     };
     // start computing from n_zero - must be a power of two
     const result_type n_zero = 16;
     const result_type initial_n = choose_initial_n<n_zero>::value;
     // static_log2_impl<>
     //
     // * Invariant:
     //                 2n
     //  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>
     struct static_log2_impl {
         BOOST_STATIC_CONSTANT(bool, c = (x >> n) > 0); // x >= 2**n ?
         BOOST_STATIC_CONSTANT(
             result_type,
             value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)
         );
     };
     template <>
     struct static_log2_impl<1, 0> {
        BOOST_STATIC_CONSTANT(result_type, value = 0);
     };
     }
 } // detail
 // --------------------------------------
 // static_log2<x>
 // ----------------------------------------
 template <static_log2_argument_type x>
 struct static_log2 {
     BOOST_STATIC_CONSTANT(
         static_log2_result_type,
         value = detail::static_log2_impl::static_log2_impl<x>::value
     );
 };
 template <>
 struct static_log2<0> { };
 }
 #endif // include guard
--- a/include/boost/integer/static_min_max.hpp
+++ b/include/boost/integer/static_min_max.hpp
@ -0,0 +1,51 @@
 //  Boost integer/static_min_max.hpp header file  ----------------------------//
 //  (C) Copyright Daryle Walker 2001.
 //  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 for updates, documentation, and revision history. 
 #ifndef BOOST_INTEGER_STATIC_MIN_MAX_HPP
 #define BOOST_INTEGER_STATIC_MIN_MAX_HPP
 #include <boost/integer_fwd.hpp>  // self include
 namespace boost
 {
 //  Compile-time extrema class declarations  ---------------------------------//
 //  Get the minimum or maximum of two values, signed or unsigned.
 template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
 struct static_signed_min
 {
    BOOST_STATIC_CONSTANT(static_min_max_signed_type, value = (Value1 > Value2) ? Value2 : Value1 );
 };
 template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
 struct static_signed_max
 {
    BOOST_STATIC_CONSTANT(static_min_max_signed_type, value = (Value1 < Value2) ? Value2 : Value1 );
 };
 template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
 struct static_unsigned_min
 {
    BOOST_STATIC_CONSTANT(static_min_max_unsigned_type, value
     = (Value1 > Value2) ? Value2 : Value1 );
 };
 template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
 struct static_unsigned_max
 {
    BOOST_STATIC_CONSTANT(static_min_max_unsigned_type, value
     = (Value1 < Value2) ? Value2 : Value1 );
 };
 }  // namespace boost
 #endif  // BOOST_INTEGER_STATIC_MIN_MAX_HPP
--- a/include/boost/integer_fwd.hpp
+++ b/include/boost/integer_fwd.hpp
@ -0,0 +1,164 @@
 //  Boost integer_fwd.hpp header file  ---------------------------------------//
 //  (C) Copyright Dave Abrahams and Daryle Walker 2001. 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.
 #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
 #include <boost/limits.hpp>  // for std::numeric_limits
 #include <boost/cstdint.hpp>  // For intmax_t
 namespace boost
 {
 #ifdef BOOST_NO_INTEGRAL_INT64_T
     typedef unsigned long static_log2_argument_type;
     typedef          int  static_log2_result_type;
     typedef long          static_min_max_signed_type;
     typedef unsigned long static_min_max_unsigned_type;
 #else
     typedef boost::uintmax_t static_min_max_unsigned_type;
     typedef boost::intmax_t  static_min_max_signed_type;
     typedef boost::uintmax_t static_log2_argument_type;
     typedef int              static_log2_result_type;
 #endif
 //  From <boost/cstdint.hpp>  ------------------------------------------------//
 // Only has typedefs or using statements, with #conditionals
 //  From <boost/integer_traits.hpp>  -----------------------------------------//
 template < class T >
    class integer_traits;
 template <  >
    class integer_traits< bool >;
 template <  >
    class integer_traits< char >;
 template <  >
    class integer_traits< signed char >;
 template <  >
    class integer_traits< unsigned char >;
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
 template <  >
    class integer_traits< wchar_t >;
 #endif
 template <  >
    class integer_traits< short >;
 template <  >
    class integer_traits< unsigned short >;
 template <  >
    class integer_traits< int >;
 template <  >
    class integer_traits< unsigned int >;
 template <  >
    class integer_traits< long >;
 template <  >
    class integer_traits< unsigned long >;
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
 template <  >
 class integer_traits<  ::boost::long_long_type>;
 template <  >
 class integer_traits<  ::boost::ulong_long_type >;
 #elif !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_MS_INT64)
 template <  >
 class integer_traits<__int64>;
 template <  >
 class integer_traits<unsigned __int64>;
 #endif
 //  From <boost/integer.hpp>  ------------------------------------------------//
 template < typename LeastInt >
    struct int_fast_t;
 template< int Bits >
    struct int_t;
 template< int Bits >
    struct uint_t;
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
    template< boost::long_long_type MaxValue >   // maximum value to require support
 #else
  template< long MaxValue >   // maximum value to require support
 #endif
    struct int_max_value_t;
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
  template< boost::long_long_type MinValue >   // minimum value to require support
 #else
  template< long MinValue >   // minimum value to require support
 #endif
    struct int_min_value_t;
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
  template< boost::ulong_long_type MaxValue >   // maximum value to require support
 #else
  template< unsigned long MaxValue >   // maximum value to require support
 #endif
    struct uint_value_t;
 //  From <boost/integer/integer_mask.hpp>  -----------------------------------//
 template < std::size_t Bit >
    struct high_bit_mask_t;
 template < std::size_t Bits >
    struct low_bits_mask_t;
 template <  >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;
 //  From <boost/integer/static_log2.hpp>  ------------------------------------//
 template <static_log2_argument_type Value >
    struct static_log2;
 template <> struct static_log2<0u>;
 //  From <boost/integer/static_min_max.hpp>  ---------------------------------//
 template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
    struct static_signed_min;
 template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
    struct static_signed_max;
 template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
    struct static_unsigned_min;
 template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
    struct static_unsigned_max;
 }  // namespace boost
 #endif  // BOOST_INTEGER_FWD_HPP
--- a/include/boost/integer_traits.hpp
+++ b/include/boost/integer_traits.hpp
@ -1,20 +1,18 @@
 /* boost integer_traits.hpp header file
 *
 * Copyright Jens Maurer 2000
- * Permission to use, copy, modify, sell, and distribute this software
+ * Distributed under the Boost Software License, Version 1.0. (See
- * is hereby granted without fee provided that the above copyright notice
+ * accompanying file LICENSE_1_0.txt or copy at
- * appears in all copies and that both that copyright notice and this
+ * http://www.boost.org/LICENSE_1_0.txt)
 * 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
@ -23,10 +21,23 @@
 // These are an implementation detail and not part of the interface
 #include <limits.h>
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+// we need wchar.h for WCHAR_MAX/MIN but not all platforms provide it,
 // 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
 //
 // We simply cannot include this header on gcc without getting copious warnings of the kind:
 //
 // ../../../boost/integer_traits.hpp:164:66: warning: use of C99 long long integer constant
 //
 // And yet there is no other reasonable implementation, so we declare this a system header
 // to suppress these warnings.
 //
 #if defined(__GNUC__) && (__GNUC__ >= 4)
 #pragma GCC system_header
 #endif
 namespace boost {
 template<class T>
@ -47,7 +58,10 @@ public:
 };
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  The definition is required even for integral static constants
+//  A definition is required even for integral static constants
 template<class T, T min_val, T max_val>
 const bool integer_traits_base<T, min_val, max_val>::is_integral;
 template<class T, T min_val, T max_val>
 const T integer_traits_base<T, min_val, max_val>::const_min;
@ -85,18 +99,33 @@ class integer_traits<unsigned char>
 template<>
 class integer_traits<wchar_t>
  : public std::numeric_limits<wchar_t>,
-#if defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
+    // Don't trust WCHAR_MIN and WCHAR_MAX with Mac OS X's native
    // 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))\
-    // SGI MIPSpro with native library doesn't have them, either
+    || (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
    public detail::integer_traits_base<wchar_t, INT_MIN, INT_MAX>
-#elif defined(__hpux) && defined(__GNUC__) && !defined(__SGI_STL_PORT)
+#elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT)
-    // GCC 2.95.2 doesn't have them on HP-UX, either
+    // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int.
-    // (also, std::numeric_limits<wchar_t> appears to return the wrong values)
+    //  - gcc 2.95.x on HP-UX
    // (also, std::numeric_limits<wchar_t> appears to return the wrong values).
    public detail::integer_traits_base<wchar_t, 0, UINT_MAX>
 #else
-    public detail::integer_traits_base<wchar_t, WCHAR_MIN, WCHAR_MAX>
+#error No WCHAR_MIN and WCHAR_MAX present, please adjust integer_traits<> for your compiler.
 #endif
 { };
 #endif // BOOST_NO_INTRINSIC_WCHAR_T
@ -137,42 +166,96 @@ class integer_traits<unsigned long>
    public detail::integer_traits_base<unsigned long, 0, ULONG_MAX>
 { };
-#ifdef ULLONG_MAX
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T)
 #if defined(ULLONG_MAX) && defined(BOOST_HAS_LONG_LONG)
 template<>
-class integer_traits<long long>
+class integer_traits< ::boost::long_long_type>
-  : public std::numeric_limits<long long>,
+  : public std::numeric_limits< ::boost::long_long_type>,
-    public detail::integer_traits_base<long long, LLONG_MIN, LLONG_MAX>
+    public detail::integer_traits_base< ::boost::long_long_type, LLONG_MIN, LLONG_MAX>
 { };
 template<>
-class integer_traits<unsigned long long>
+class integer_traits< ::boost::ulong_long_type>
-  : public std::numeric_limits<unsigned long long>,
+  : public std::numeric_limits< ::boost::ulong_long_type>,
-    public detail::integer_traits_base<unsigned long long, 0, ULLONG_MAX>
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULLONG_MAX>
 { };
-#elif defined(ULONG_LONG_MAX)
+
 #elif defined(ULONG_LONG_MAX) && defined(BOOST_HAS_LONG_LONG)
 template<>
-class integer_traits<long long>
+class integer_traits< ::boost::long_long_type>  : public std::numeric_limits< ::boost::long_long_type>,    public detail::integer_traits_base< ::boost::long_long_type, LONG_LONG_MIN, LONG_LONG_MAX>{ };
  : 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>
+class integer_traits< ::boost::ulong_long_type>
-  : public std::numeric_limits<unsigned long long>,
+  : public std::numeric_limits< ::boost::ulong_long_type>,
-    public detail::integer_traits_base<unsigned long long, 0, ULONG_LONG_MAX>
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONG_LONG_MAX>
 { };
-#elif defined(ULONGLONG_MAX)
+
 #elif defined(ULONGLONG_MAX) && defined(BOOST_HAS_LONG_LONG)
 template<>
-class integer_traits<long long>
+class integer_traits< ::boost::long_long_type>
-  : public std::numeric_limits<long long>,
+  : public std::numeric_limits< ::boost::long_long_type>,
-    public detail::integer_traits_base<long long, LONGLONG_MIN, LONGLONG_MAX>
+    public detail::integer_traits_base< ::boost::long_long_type, LONGLONG_MIN, LONGLONG_MAX>
 { };
 template<>
-class integer_traits<unsigned long long>
+class integer_traits< ::boost::ulong_long_type>
-  : public std::numeric_limits<unsigned long long>,
+  : public std::numeric_limits< ::boost::ulong_long_type>,
-    public detail::integer_traits_base<unsigned long long, 0, ULONGLONG_MAX>
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONGLONG_MAX>
 { };
 #elif defined(_LLONG_MAX) && defined(_C2) && defined(BOOST_HAS_LONG_LONG)
 template<>
 class integer_traits< ::boost::long_long_type>
  : public std::numeric_limits< ::boost::long_long_type>,
    public detail::integer_traits_base< ::boost::long_long_type, -_LLONG_MAX - _C2, _LLONG_MAX>
 { };
 template<>
 class integer_traits< ::boost::ulong_long_type>
  : public std::numeric_limits< ::boost::ulong_long_type>,
    public detail::integer_traits_base< ::boost::ulong_long_type, 0, _ULLONG_MAX>
 { };
 #elif defined(BOOST_HAS_LONG_LONG)
 //
 // we have long long but no constants, this happens for example with gcc in -ansi mode,
 // we'll just have to work out the values for ourselves (assumes 2's compliment representation):
 //
 template<>
 class integer_traits< ::boost::long_long_type>
  : public std::numeric_limits< ::boost::long_long_type>,
    public detail::integer_traits_base< ::boost::long_long_type, (1LL << (sizeof(::boost::long_long_type) * CHAR_BIT - 1)), ~(1LL << (sizeof(::boost::long_long_type) * CHAR_BIT - 1))>
 { };
 template<>
 class integer_traits< ::boost::ulong_long_type>
  : public std::numeric_limits< ::boost::ulong_long_type>,
    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ~0uLL>
 { };
 #elif defined(BOOST_HAS_MS_INT64)
 template<>
 class integer_traits< __int64>
  : public std::numeric_limits< __int64>,
    public detail::integer_traits_base< __int64, _I64_MIN, _I64_MAX>
 { };
 template<>
 class integer_traits< unsigned __int64>
  : public std::numeric_limits< unsigned __int64>,
    public detail::integer_traits_base< unsigned __int64, 0, _UI64_MAX>
 { };
 #endif
 #endif
 } // namespace boost
 #endif /* BOOST_INTEGER_TRAITS_HPP */
--- a/include/boost/stdint.h
+++ b/include/boost/stdint.h
@ -1,272 +0,0 @@
 //  boost stdint.h header file  ---------------------------------------------//
 //  (C) Copyright boost.org 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.
 //  NOTE WELL: This is an implementation of the ISO C Standard (1999) stdint.h
 //  header.  C++ programs are advised to use <boost/cstdint.hpp> rather than
 //  this header.
 //  NOTE OF OBSOLESCENCE: In general, this header file cannot detect
 //  whether the current translation unit somewhere includes ISO C99
 //  <stdint.h> or not.  For example, in case BOOST_SYSTEM_HAS_STDINT_H
 //  is not defined and ISO C99 <stdint.h> has been included before,
 //  this file will re-define ISO C99 reserved file-scope identifiers
 //  such as int8_t (see ISO C99 7.1.3 and 7.18).  Defining the macro
 //  BOOST_SYSTEM_HAS_STDINT_H is not sufficient in general, in
 //  particular if a partly conformant <stdint.h> header is available
 //  on the platform, e.g. Comeau C++ with GNU glibc 2.1.2.
 //
 //  In order to avoid incompatibilities with ISO C99, this header
 //  should not be used at all, and it may be deleted in the future.
 //  C++ programs which require ISO C99 <stdint.h> functionality are
 //  strongly advised to use <boost/cstdint.hpp> instead, which
 //  provides <stdint.h> names in namespace boost, e.g. boost::int8_t.
 //  Revision History
 //   12 Nov 00  obsoleted (Jens Maurer)
 //   23 Sep 00  INTXX_C support added (John Maddock)
 //   22 Sep 00  64-bit support for Borland & Microsoft compilers (John Maddock)
 //    8 Aug 99  Initial version (Beman Dawes)
 #ifndef BOOST_STDINT_H
 #define BOOST_STDINT_H
 #include <boost/config.hpp>
 #ifdef BOOST_SYSTEM_HAS_STDINT_H
 #include <stdint.h>
 #else
 #include <limits.h> // implementation artifact; not part of interface
 //  These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit
 //  platforms.  For other systems, they will have to be hand tailored.
 //
 //  Because the fast types are assumed to be the same as the undecorated types,
 //  it may be possible to hand tailor a more efficient implementation.  Such
 //  an optimization may be illusionary; on the Intel x86-family 386 on, for
 //  example, byte arithmetic and load/stores are as fast as "int" sized ones.
 //  8-bit types  -------------------------------------------------------------//
 # if UCHAR_MAX == 0xff
     typedef signed char     int8_t;
     typedef signed char     int_least8_t;
     typedef signed char     int_fast8_t;
     typedef unsigned char   uint8_t;
     typedef unsigned char   uint_least8_t;
     typedef unsigned char   uint_fast8_t;
 # else
 #    error defaults not correct; you must hand modify boost/stdint.h
 # endif
 //  16-bit types  ------------------------------------------------------------//
 # if USHRT_MAX == 0xffff
     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;
 # else
 #    error defaults not correct; you must hand modify boost/stdint.h
 # endif
 //  32-bit types  ------------------------------------------------------------//
 # if UINT_MAX == 0xffffffff
     typedef int             int32_t;
     typedef int             int_least32_t;
     typedef int             int_fast32_t;
     typedef unsigned int    uint32_t;
     typedef unsigned int    uint_least32_t;
     typedef unsigned int    uint_fast32_t;
 # elif ULONG_MAX == 0xffffffff
     typedef long            int32_t;
     typedef long            int_least32_t;
     typedef long            int_fast32_t;
     typedef unsigned long   uint32_t;
     typedef unsigned long   uint_least32_t;
     typedef unsigned long   uint_fast32_t;
 # else
 #    error defaults not correct; you must hand modify boost/stdint.h
 # endif
 //  64-bit types + intmax_t and uintmax_t  -----------------------------------//
 # if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) && !(defined(_WIN32) && defined(__GNUC__))
 #    if(defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615) ||  \
        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615)
                                                                 // 2**64 - 1
     typedef long long            intmax_t;
     typedef unsigned long long   uintmax_t;
     typedef long long            int64_t;
     typedef long long            int_least64_t;
     typedef long long            int_fast64_t;
     typedef unsigned long long   uint64_t;
     typedef unsigned long long   uint_least64_t;
     typedef unsigned long long   uint_fast64_t;
 #    else
 #       error defaults not correct; you must hand modify boost/stdint.h
 #    endif
 # elif ULONG_MAX != 0xffffffff
 #    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
     typedef long                 intmax_t;
     typedef unsigned long        uintmax_t;
     typedef long                 int64_t;
     typedef long                 int_least64_t;
     typedef long                 int_fast64_t;
     typedef unsigned long        uint64_t;
     typedef unsigned long        uint_least64_t;
     typedef unsigned long        uint_fast64_t;
 #    else
 #       error defaults not correct; you must hand modify boost/stdint.h
 #    endif
 # elif (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520))
     //
     // we have Borland/Microsoft __int64:
     //
     typedef __int64             intmax_t;
     typedef unsigned __int64    uintmax_t;
     typedef __int64             int64_t;
     typedef __int64             int_least64_t;
     typedef __int64             int_fast64_t;
     typedef unsigned __int64    uint64_t;
     typedef unsigned __int64    uint_least64_t;
     typedef unsigned __int64    uint_fast64_t;
 # else // assume no 64-bit integers
 #define BOOST_NO_INT64_T
     typedef int32_t              intmax_t;
     typedef uint32_t             uintmax_t;
 # endif
 #endif  // BOOST_SYSTEM_HAS_STDINT_H not defined
 #endif  // BOOST_STDINT_H
 /****************************************************
 Macro definition section:
 Define various INTXX_C macros only if
 __STDC_CONSTANT_MACROS is defined.
 Undefine the macros if __STDC_CONSTANT_MACROS is
 not defined and the macros are (cf <cassert>).
 Added 23rd September (John Maddock).
 ******************************************************/
 #if defined(__STDC_CONSTANT_MACROS) && !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED)
 #define BOOST__STDC_CONSTANT_MACROS_DEFINED
 #if (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520))
 //
 // Borland/Microsoft compilers have width specific suffixes:
 //
 #define INT8_C(value)     value##i8
 #define INT16_C(value)    value##i16
 #define INT32_C(value)    value##i32
 #define INT64_C(value)    value##i64
 #ifdef __BORLANDC__
 // Borland bug: appending ui8 makes the type
 // a signed char!!!!
 #define UINT8_C(value)    static_cast<unsigned char>(value##u)
 #else
 #define UINT8_C(value)    value##ui8
 #endif
 #define UINT16_C(value)   value##ui16
 #define UINT32_C(value)   value##ui32
 #define UINT64_C(value)   value##ui64
 #define INTMAX_C(value)   value##i64
 #define UINTMAX_C(value)  value##ui64
 #else
 //  do it the old fashioned way:
 //  8-bit types  -------------------------------------------------------------//
 # if UCHAR_MAX == 0xff
 #define INT8_C(value) static_cast<int8_t>(value)
 #define UINT8_C(value) static_cast<uint8_t>(value##u)
 # endif
 //  16-bit types  ------------------------------------------------------------//
 # if USHRT_MAX == 0xffff
 #define INT16_C(value) static_cast<int16_t>(value)
 #define UINT16_C(value) static_cast<uint16_t>(value##u)
 # endif
 //  32-bit types  ------------------------------------------------------------//
 # if UINT_MAX == 0xffffffff
 #define INT32_C(value) value
 #define UINT32_C(value) value##u
 # elif ULONG_MAX == 0xffffffff
 #define INT32_C(value) value##L
 #define UINT32_C(value) value##uL
 # endif
 //  64-bit types + intmax_t and uintmax_t  -----------------------------------//
 # if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) && !(defined(_WIN32) && defined(__GNUC__))
 #    if(defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615) ||  \
        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615)
 #define INT64_C(value) value##LL
 #define UINT64_C(value) value##uLL
 #    else
 #       error defaults not correct; you must hand modify boost/stdint.h
 #    endif
 # elif ULONG_MAX != 0xffffffff
 #    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
 #define INT64_C(value) value##L
 #define UINT64_C(value) value##uL
 #    else
 #       error defaults not correct; you must hand modify boost/stdint.h
 #    endif
 # elif (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520))
     //
     // we have Borland/Microsoft __int64:
     //
 #define INT64_C(value) value##i64
 #define UINT64_C(value) value##ui64
 # endif
 #ifdef BOOST_NO_INT64_T
 #define INTMAX_C(value) INT32_C(value)
 #define UINTMAX_C(value) UINT32_C(value)
 #else
 #define INTMAX_C(value) INT64_C(value)
 #define UINTMAX_C(value) UINT64_C(value)
 #endif
 #endif // Borland/MS specific
 #elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS)
 //
 // undef all the macros:
 //
 #undef INT8_C
 #undef INT16_C
 #undef INT32_C
 #undef INT64_C
 #undef UINT8_C
 #undef UINT16_C
 #undef UINT32_C
 #undef UINT64_C
 #undef INTMAX_C
 #undef UINTMAX_C
 #endif // constant macros
--- a/index.htm
+++ b/index.htm
@ -1,98 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Language" content="en-us">
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Boost Integer Library</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <table border="1" bgcolor="#007F7F" cellpadding="2">
  <tr>
    <td bgcolor="#FFFFFF"><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="#FFFFFF"><big>Home </big></font></a></td>
    <td><a href="../libraries.htm"><font face="Arial" color="#FFFFFF"><big>Libraries </big></font></a></td>
    <td><a href="../../people/people.htm"><font face="Arial" color="#FFFFFF"><big>People </big></font></a></td>
    <td><a href="../../more/faq.htm"><font face="Arial" color="#FFFFFF"><big>FAQ </big></font></a></td>
    <td><a href="../../more/index.htm"><font face="Arial" color="#FFFFFF"><big>More </big></font></a></td>
  </tr>
 </table>
 <h1>Boost Integer Library</h1>
 <table border="1" cellpadding="5">
  <tr>
    <td align="center"><b><i>Header / Docs</i></b></td>
    <td align="center"><b><i>Contents</i></b></td>
    <td align="center"><b><i>Use</i></b></td>
  </tr>
  <tr>
    <td align="center"><code><a href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;<br>
      </a></code><a href="cstdint.htm"><br>
      documentation</a>
    </td>
    <td valign="top">Typedef's based on the 1999 C Standard header &lt;<code>stdint.h&gt;</code>, wrapped in namespace boost.
      This implementation may #include the compiler
      supplied &lt;<code>stdint.h&gt;</code>, if present.  </td>
    <td valign="top">Supplies typedefs for standard integer types such as <code> int32_t</code> or <code>uint_least16_t</code>.
      Use in preference to &lt;<code>stdint.h&gt;</code>
      for enhanced portability.  Furthermore, all names are safely placed in the boost namespace.</td>
  </tr>
  <tr>
    <td align="center"><code><a href="../../boost/integer_traits.hpp">&lt;boost/integer_traits.hpp&gt;</a></code><br>
    <br>
    <a href="integer_traits.html">documentation</a>
    </td>
    <td valign="top">Template class <code>boost::integer_traits</code>, derived from <code>std::numeric_limits</code>.&nbsp;
      Adds <code>const_min</code> and <code>const_max</code> members.</td>
    <td valign="top">Use to obtain the characteristics of a known integer type.</td>
  </tr>
  <tr>
    <td align="center"><code><a href="../../boost/integer.hpp">&lt;boost/integer.hpp&gt;</a><br>
      <br>
      </code><a href="integer.htm">documentation</a></td>
    <td valign="top">Templates for integer type selection based on properties such as
      maximum value or number of bits.</td>
    <td valign="top">Use to select the type an integer when some property such as maximum value or number of bits is known.
      Useful for generic programming. </td>
  </tr>
 </table>
 <h2>Rationale</h2>
 <p>The organization of boost integer headers and classes is designed to take
 advantage of <code>&lt;stdint.h&gt;</code> types from the 1999 C standard
 without resorting to undefined behavior in terms of
 the 1998 C++ standard.&nbsp; The header <code>&lt;boost/cstdint.hpp&gt;</code>
 makes the standard integer types safely available in namespace boost without placing any names in namespace std. As always, the intension is to complement rather than
 compete with the C++ Standard Library.&nbsp; Should some future C++ standard
 include <code>&lt;stdint.h&gt;</code> and <code>&lt;cstdint&gt;</code>, then <code>&lt;boost/cstdint.hpp&gt;</code>
 will continue to function, but will become redundant and may be safely deprecated.</p>
 <p>Because these are boost headers, their names conform to boost header naming
 conventions rather than C++ Standard Library header naming conventions.
 <h2>Caveat emptor</h2>
 <p>As an
      implementation artifact, certain C &lt;limits.h&gt; macro names may possibly be
 visible to users of &lt;boost/cstdint.hpp&gt;.&nbsp; Don't use these macros; they are not part of
 any Boost specified interface.&nbsp;
      Use boost:: integer_traits&lt;&gt; or std::numeric_limits&lt;&gt; instead.</p>
 <p>
 As another implementation artifact, certain C
 <code>&lt;stdint.h&gt;</code> typedef names may possibly be visible in the
 global namespace to users of <code>&lt;boost/cstdint.hpp&gt;</code>.
 Don't use these names, they are not part of any Boost specified
 interface.  Use the respective names in namespace <code>boost</code>
 instead.
 <hr>
 <p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->10 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14373" -->
 </p>
 </body>
 </html>
--- a/index.html
+++ b/index.html
@ -0,0 +1,16 @@
 <html>
 <head>
 <meta http-equiv="refresh" content="0; URL=doc/html/index.html">
 </head>
 <body>
 Automatic redirection failed, please go to
 <a href="doc/html/index.html">doc/html/index.html</a>.
      <P>Copyright Beman Dawes, Daryle Walker, Gennaro Prota and John Maddock 2001-2009</P>
      <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
            LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
 </body>
 </html>
--- a/integer.htm
+++ b/integer.htm
@ -1,112 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Integer Type Selection Templates</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Integer
 Type Selection Templates</h1>
 <p>The <code><a href="../../boost/integer.hpp">&lt;boost/integer.hpp&gt;</a></code>
 type selection templates allow integer types to be selected based on desired
 characteristics such as number of bits or maximum value.&nbsp; This facility is
 particularly useful for solving generic programming problems.</p>
 <p>The templates <b>int_t&lt;&gt;</b> and <b>uint_t&lt;&gt;</b> supply typedefs <b>least</b>
 and <b>fast</b>.&nbsp; The <b>least</b> type be the smallest type which holds at
 least the number of bits (including sign) specified. The <b>fast</b> type will
 be at least as large as the <b>least</b> type, but may possible be larger.&nbsp;
 There is no guarantee that the <b>fast</b> type will actually be faster than
 other possible types.</p>
 <h2>Alternative</h2>
 <p>If the number of bits required is known beforehand, it may be more
 appropriate to use the types supplied in <code><a href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;</a></code>.</p>
 <h2>Synopsis</h2>
 <blockquote>
 <pre>namespace boost
 {
  //  fast integers from least integers
  // int_fast_t&lt;&gt; works correctly for unsigned too, in spite of the name.
  template&lt; typename LeastInt &gt;  // Required: LeastInt is integral type, not bool
  struct int_fast_t { typedef LeastInt fast; }; // implementations may specialize
  //  signed
  template&lt; int Bits &gt;   // bits (including sign) required, 0-32 valid
  struct int_t 
  {
      typedef <i>implementation-supplied</i>  least;
      typedef int_fast_t&lt;least&gt;::fast  fast;
  };
  //  unsigned
  template&lt; int Bits &gt;   // bits required, 0-32 valid
  struct uint_t 
  {
      typedef <i>implementation-supplied</i>  least;
      typedef int_fast_t&lt;least&gt;::fast  fast;
      // int_fast_t&lt;&gt; works correctly for unsigned too, in spite of the name.
  };
 } // namespace boost
 </pre>
 </blockquote>
 <p>[Templates to select type based on maximum value are under development.]
 </p>
 <h2>Example</h2>
 <blockquote>
  <pre>#include &lt;boost/integer.hpp&gt;
 using boost::int_t;
 ...
 int_t&lt;24&gt;::least my_var;  </pre>
 </blockquote>
 <h2>Demonstration Program</h2>
 <p>The program <a href="integer_test.cpp">integer_test.cpp</a> is a not very
 smart demonstration of the results from instantiating various <b>int_t&lt;&gt;</b>
 and <b>uint_t&lt;&gt;</b> examples.</p>
 <h2>Rationale</h2>
 <p>The rationale for the design of the templates in this header includes:</p>
 <ul>
  <li>Avoid&nbsp; recursion because of concern about C++'s limited guaranteed
    recursion depth (17).</li>
  <li>Avoid macros on general principles.</li>
  <li>Try to keep the design as simple as possible.</li>
 </ul>
 <h2>Credits</h2>
 <p>The author of the Boost integer type choosing templates is <a href="../../people/beman_dawes.html">Beman
 Dawes</a>.&nbsp; He thanks to <a href="../../people/valentin_bonnard.htm"> Valentin Bonnard</a> and
 <a href="../../people/kevlin_henney.htm"> Kevlin Henney</a> for sharing their designs for  similar templates.</p>
 <hr>
 <p>Revised&nbsp; August 31, 1999</p>
 <p><EFBFBD> Copyright Beman Dawes 1999. Permission to copy, use, modify, sell
 and distribute this document is granted provided this copyright notice appears in all
 copies. This document is provided &quot;as is&quot; without express or implied warranty,
 and with no claim as to its suitability for any purpose.</p>
 <p></p>
 <p>&nbsp;</p>
 </body>
 </html>
--- a/integer_test.cpp
+++ b/integer_test.cpp
@ -1,317 +0,0 @@
 //  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
 //   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
 //   31 Aug 99  Initial version
 #include <iostream>
 #include <boost/integer.hpp>
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
 namespace
 {
    void test( long ) { std::cout << "long\n"; }
    void test( int ) { std::cout << "int\n"; }
    void test( short ) { std::cout << "short\n"; }
    void test( signed char ) { std::cout << "signed char\n"; }
    void test( unsigned long ) { std::cout << "unsigned long\n"; }
    void test( unsigned int ) { std::cout << "unsigned int\n"; }
    void test( unsigned short ) { std::cout << "unsigned short\n"; }
    void test( unsigned char ) { std::cout << "unsigned char\n"; }
 } // unnamed namespace
 // just to prove it works, specialize int_fast_t<short> to yield long
 namespace boost
 {
    template<> struct int_fast_t<short> { typedef long fast; };
 }
 int test_main(int,char**)
 {
     using boost::int_t;
     using boost::uint_t;
 #ifdef BOOST_SHOW_TYPES
     std::cout << 32 << ' '; test( int_t<32>::least() ); 
     std::cout << 31 << ' '; test( int_t<31>::least() ); 
     std::cout << 30 << ' '; test( int_t<30>::least() ); 
     std::cout << 29 << ' '; test( int_t<29>::least() ); 
     std::cout << 28 << ' '; test( int_t<28>::least() ); 
     std::cout << 27 << ' '; test( int_t<27>::least() ); 
     std::cout << 26 << ' '; test( int_t<26>::least() ); 
     std::cout << 25 << ' '; test( int_t<25>::least() ); 
     std::cout << 24 << ' '; test( int_t<24>::least() ); 
     std::cout << 23 << ' '; test( int_t<23>::least() ); 
     std::cout << 22 << ' '; test( int_t<22>::least() ); 
     std::cout << 21 << ' '; test( int_t<21>::least() ); 
     std::cout << 20 << ' '; test( int_t<20>::least() ); 
     std::cout << 19 << ' '; test( int_t<19>::least() ); 
     std::cout << 18 << ' '; test( int_t<18>::least() ); 
     std::cout << 17 << ' '; test( int_t<17>::least() ); 
     std::cout << 16 << ' '; test( int_t<16>::least() ); 
     std::cout << 15 << ' '; test( int_t<15>::least() ); 
     std::cout << 14 << ' '; test( int_t<14>::least() ); 
     std::cout << 13 << ' '; test( int_t<13>::least() ); 
     std::cout << 12 << ' '; test( int_t<12>::least() ); 
     std::cout << 11 << ' '; test( int_t<11>::least() ); 
     std::cout << 10 << ' '; test( int_t<10>::least() ); 
     std::cout << 9 << ' '; test( int_t<9>::least() ); 
     std::cout << 8 << ' '; test( int_t<8>::least() ); 
     std::cout << 7 << ' '; test( int_t<7>::least() ); 
     std::cout << 6 << ' '; test( int_t<6>::least() ); 
     std::cout << 5 << ' '; test( int_t<5>::least() ); 
     std::cout << 4 << ' '; test( int_t<4>::least() ); 
     std::cout << 3 << ' '; test( int_t<3>::least() ); 
     std::cout << 2 << ' '; test( int_t<2>::least() ); 
     std::cout << 1 << ' '; test( int_t<1>::least() ); 
     std::cout << 0 << ' '; test( int_t<0>::least() ); 
     std::cout << 32 << ' '; test( int_t<32>::fast() ); 
     std::cout << 31 << ' '; test( int_t<31>::fast() ); 
     std::cout << 30 << ' '; test( int_t<30>::fast() ); 
     std::cout << 29 << ' '; test( int_t<29>::fast() ); 
     std::cout << 28 << ' '; test( int_t<28>::fast() ); 
     std::cout << 27 << ' '; test( int_t<27>::fast() ); 
     std::cout << 26 << ' '; test( int_t<26>::fast() ); 
     std::cout << 25 << ' '; test( int_t<25>::fast() ); 
     std::cout << 24 << ' '; test( int_t<24>::fast() ); 
     std::cout << 23 << ' '; test( int_t<23>::fast() ); 
     std::cout << 22 << ' '; test( int_t<22>::fast() ); 
     std::cout << 21 << ' '; test( int_t<21>::fast() ); 
     std::cout << 20 << ' '; test( int_t<20>::fast() ); 
     std::cout << 19 << ' '; test( int_t<19>::fast() ); 
     std::cout << 18 << ' '; test( int_t<18>::fast() ); 
     std::cout << 17 << ' '; test( int_t<17>::fast() ); 
     std::cout << 16 << ' '; test( int_t<16>::fast() ); 
     std::cout << 15 << ' '; test( int_t<15>::fast() ); 
     std::cout << 14 << ' '; test( int_t<14>::fast() ); 
     std::cout << 13 << ' '; test( int_t<13>::fast() ); 
     std::cout << 12 << ' '; test( int_t<12>::fast() ); 
     std::cout << 11 << ' '; test( int_t<11>::fast() ); 
     std::cout << 10 << ' '; test( int_t<10>::fast() ); 
     std::cout << 9 << ' '; test( int_t<9>::fast() ); 
     std::cout << 8 << ' '; test( int_t<8>::fast() ); 
     std::cout << 7 << ' '; test( int_t<7>::fast() ); 
     std::cout << 6 << ' '; test( int_t<6>::fast() ); 
     std::cout << 5 << ' '; test( int_t<5>::fast() ); 
     std::cout << 4 << ' '; test( int_t<4>::fast() ); 
     std::cout << 3 << ' '; test( int_t<3>::fast() ); 
     std::cout << 2 << ' '; test( int_t<2>::fast() ); 
     std::cout << 1 << ' '; test( int_t<1>::fast() ); 
     std::cout << 0 << ' '; test( int_t<0>::fast() ); 
     std::cout << 32 << ' '; test( uint_t<32>::least() ); 
     std::cout << 31 << ' '; test( uint_t<31>::least() ); 
     std::cout << 30 << ' '; test( uint_t<30>::least() ); 
     std::cout << 29 << ' '; test( uint_t<29>::least() ); 
     std::cout << 28 << ' '; test( uint_t<28>::least() ); 
     std::cout << 27 << ' '; test( uint_t<27>::least() ); 
     std::cout << 26 << ' '; test( uint_t<26>::least() ); 
     std::cout << 25 << ' '; test( uint_t<25>::least() ); 
     std::cout << 24 << ' '; test( uint_t<24>::least() ); 
     std::cout << 23 << ' '; test( uint_t<23>::least() ); 
     std::cout << 22 << ' '; test( uint_t<22>::least() ); 
     std::cout << 21 << ' '; test( uint_t<21>::least() ); 
     std::cout << 20 << ' '; test( uint_t<20>::least() ); 
     std::cout << 19 << ' '; test( uint_t<19>::least() ); 
     std::cout << 18 << ' '; test( uint_t<18>::least() ); 
     std::cout << 17 << ' '; test( uint_t<17>::least() ); 
     std::cout << 16 << ' '; test( uint_t<16>::least() ); 
     std::cout << 15 << ' '; test( uint_t<15>::least() ); 
     std::cout << 14 << ' '; test( uint_t<14>::least() ); 
     std::cout << 13 << ' '; test( uint_t<13>::least() ); 
     std::cout << 12 << ' '; test( uint_t<12>::least() ); 
     std::cout << 11 << ' '; test( uint_t<11>::least() ); 
     std::cout << 10 << ' '; test( uint_t<10>::least() ); 
     std::cout << 9 << ' '; test( uint_t<9>::least() ); 
     std::cout << 8 << ' '; test( uint_t<8>::least() ); 
     std::cout << 7 << ' '; test( uint_t<7>::least() ); 
     std::cout << 6 << ' '; test( uint_t<6>::least() ); 
     std::cout << 5 << ' '; test( uint_t<5>::least() ); 
     std::cout << 4 << ' '; test( uint_t<4>::least() ); 
     std::cout << 3 << ' '; test( uint_t<3>::least() ); 
     std::cout << 2 << ' '; test( uint_t<2>::least() ); 
     std::cout << 1 << ' '; test( uint_t<1>::least() ); 
     std::cout << 0 << ' '; test( uint_t<0>::least() ); 
     std::cout << 32 << ' '; test( uint_t<32>::fast() ); 
     std::cout << 31 << ' '; test( uint_t<31>::fast() ); 
     std::cout << 30 << ' '; test( uint_t<30>::fast() ); 
     std::cout << 29 << ' '; test( uint_t<29>::fast() ); 
     std::cout << 28 << ' '; test( uint_t<28>::fast() ); 
     std::cout << 27 << ' '; test( uint_t<27>::fast() ); 
     std::cout << 26 << ' '; test( uint_t<26>::fast() ); 
     std::cout << 25 << ' '; test( uint_t<25>::fast() ); 
     std::cout << 24 << ' '; test( uint_t<24>::fast() ); 
     std::cout << 23 << ' '; test( uint_t<23>::fast() ); 
     std::cout << 22 << ' '; test( uint_t<22>::fast() ); 
     std::cout << 21 << ' '; test( uint_t<21>::fast() ); 
     std::cout << 20 << ' '; test( uint_t<20>::fast() ); 
     std::cout << 19 << ' '; test( uint_t<19>::fast() ); 
     std::cout << 18 << ' '; test( uint_t<18>::fast() ); 
     std::cout << 17 << ' '; test( uint_t<17>::fast() ); 
     std::cout << 16 << ' '; test( uint_t<16>::fast() ); 
     std::cout << 15 << ' '; test( uint_t<15>::fast() ); 
     std::cout << 14 << ' '; test( uint_t<14>::fast() ); 
     std::cout << 13 << ' '; test( uint_t<13>::fast() ); 
     std::cout << 12 << ' '; test( uint_t<12>::fast() ); 
     std::cout << 11 << ' '; test( uint_t<11>::fast() ); 
     std::cout << 10 << ' '; test( uint_t<10>::fast() ); 
     std::cout << 9 << ' '; test( uint_t<9>::fast() ); 
     std::cout << 8 << ' '; test( uint_t<8>::fast() ); 
     std::cout << 7 << ' '; test( uint_t<7>::fast() ); 
     std::cout << 6 << ' '; test( uint_t<6>::fast() ); 
     std::cout << 5 << ' '; test( uint_t<5>::fast() ); 
     std::cout << 4 << ' '; test( uint_t<4>::fast() ); 
     std::cout << 3 << ' '; test( uint_t<3>::fast() ); 
     std::cout << 2 << ' '; test( uint_t<2>::fast() ); 
     std::cout << 1 << ' '; test( uint_t<1>::fast() ); 
     std::cout << 0 << ' '; test( uint_t<0>::fast() );
 #endif
    long v = 0x7FFFFFFF;
    BOOST_TEST( int_t<32>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<31>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<30>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<29>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<28>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<27>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<26>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<25>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<24>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<23>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<22>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<21>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<20>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<19>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<18>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<17>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<16>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<15>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<14>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<13>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<12>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<11>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<10>::least(v) == v );    v >>= 1;
    BOOST_TEST( int_t<9>::least(v) == v );     v >>= 1;
    BOOST_TEST( int_t<8>::least(v) == v );     v >>= 1;
    BOOST_TEST( int_t<7>::least(v) == v );     v >>= 1;
    BOOST_TEST( int_t<6>::least(v) == v );     v >>= 1;
    BOOST_TEST( int_t<5>::least(v) == v );     v >>= 1;
    BOOST_TEST( int_t<4>::least(v) == v );     v >>= 1;
    BOOST_TEST( int_t<3>::least(v) == v );     v >>= 1;
    BOOST_TEST( int_t<2>::least(v) == v );     v >>= 1;
    BOOST_TEST( int_t<1>::least(v) == v );     v >>= 1;
    BOOST_TEST( int_t<0>::least(v) == v );
    v = 0x7FFFFFFF;
    BOOST_TEST( int_t<32>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<31>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<30>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<29>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<28>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<27>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<26>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<25>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<24>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<23>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<22>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<21>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<20>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<19>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<18>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<17>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<16>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<15>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<14>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<13>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<12>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<11>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<10>::fast(v) == v );    v >>= 1;
    BOOST_TEST( int_t<9>::fast(v) == v );     v >>= 1;
    BOOST_TEST( int_t<8>::fast(v) == v );     v >>= 1;
    BOOST_TEST( int_t<7>::fast(v) == v );     v >>= 1;
    BOOST_TEST( int_t<6>::fast(v) == v );     v >>= 1;
    BOOST_TEST( int_t<5>::fast(v) == v );     v >>= 1;
    BOOST_TEST( int_t<4>::fast(v) == v );     v >>= 1;
    BOOST_TEST( int_t<3>::fast(v) == v );     v >>= 1;
    BOOST_TEST( int_t<2>::fast(v) == v );     v >>= 1;
    BOOST_TEST( int_t<1>::fast(v) == v );     v >>= 1;
    BOOST_TEST( int_t<0>::fast(v) == v );
    unsigned long u = 0xFFFFFFFF;
    BOOST_TEST( uint_t<32>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<31>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<30>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<29>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<28>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<27>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<26>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<25>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<24>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<23>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<22>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<21>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<20>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<19>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<18>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<17>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<16>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<15>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<14>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<13>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<11>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<12>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<10>::least(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<9>::least(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<8>::least(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<7>::least(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<6>::least(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<5>::least(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<4>::least(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<3>::least(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<2>::least(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<1>::least(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<0>::least(u) == u );
    u = 0xFFFFFFFF;
    BOOST_TEST( uint_t<32>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<31>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<30>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<29>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<28>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<27>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<26>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<25>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<24>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<23>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<22>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<21>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<20>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<19>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<18>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<17>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<16>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<15>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<14>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<13>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<12>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<11>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<10>::fast(u) == u );    u >>= 1;
    BOOST_TEST( uint_t<9>::fast(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<8>::fast(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<7>::fast(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<6>::fast(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<5>::fast(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<4>::fast(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<3>::fast(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<2>::fast(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<1>::fast(u) == u );     u >>= 1;
    BOOST_TEST( uint_t<0>::fast(u) == u );
    return 0;
 }
--- a/integer_traits.html
+++ b/integer_traits.html
@ -1,89 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <title>integer_traits: Compile-Time Limits for Integral Types</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <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>
 The C++ Standard Library &lt;limits&gt; header supplies a class template
 numeric_limits&lt;&gt; with specializations for each fundamental
 type.</p>
 <p>
 For integer types, the interesting members of std::numeric_limits&lt;&gt; are:
 <pre>   static const bool is_specialized; // will be true for integers
   static T min() throw();
   static T max() throw();
   static const int digits;     // for integers, # value bits
   static const int digits10;     
   static const bool is_signed;
   static const bool is_integer; // will be true for integers</pre>
 For many uses, these are sufficient.  But min() and max() are problematical because they are not constant expressions
 (std::5.19), yet some usages require constant expressions.
 <p>
 The template class <code>integer_traits</code> addresses this
 problem.
 <h2>Header <code><a href="../../boost/integer_traits.hpp">integer_traits.hpp</a></code> Synopsis</h2>
 <pre>namespace boost {
  template&lt;class T&gt;
  class integer_traits : public std::numeric_limits&lt;T&gt;
  {
    static const bool is_integral = false;
  };
  // specializations for all integral types
 }</pre>
 <h2>Description</h2>
 Template class <code>integer_traits</code> is derived from
 <code>std::numeric_limits</code>.  In general, it adds the single
 <code>bool</code> member <code>is_integral</code> with the
 compile-time constant value <code>false</code>.  However, for all
 integral types <code>T</code> (std::3.9.1/7 [basic.fundamental]),
 there are specializations provided with the following compile-time
 constants defined:
 <p>
 <table border=1>
 <tr><th>member</th><th>type</th><th>value</th></tr>
 <tr><td><code>is_integral</code></td><td>bool</td><td><code>true</code></td></tr>
 <tr><td><code>const_min</code></td><td><code>T</code></td><td>equivalent
 to <code>std::numeric_limits&lt;T&gt;::min()</code></td></tr>
 <tr><td><code>const_max</code></td><td><code>T</code></td><td>equivalent
 to <code>std::numeric_limits&lt;T&gt;::max()</code></td></tr>
 </table>
 <p>
 <em>Note:</em> A flag <code>is_integral</code> is provided, because a
 user-defined integer class should specialize
 <code>std::numeric_limits&lt;&gt;::is_integer = true</code>,
 nonetheless compile-time constants <code>const_min</code> and
 <code>const_max</code> cannot be provided for that user-defined class.
 <h2>
 Test Program</h2>
 <p>
 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>
 Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer
 traits idea on the boost mailing list in August 1999.
 <hr>
 <a href="../../people/jens_maurer.htm">
 Jens Maurer</a>, 2000-02-20
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -0,0 +1,25 @@
 #~ 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 ;
 project : requirements <warnings>all <toolset>gcc:<cxxflags>-Wextra ;
 test-suite integer
    : 
        [ run cstdint_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long ]
        [ run cstdint_test2.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long ]
        [ run integer_traits_test.cpp ]
        [ run integer_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long <toolset>sun:<cxxflags>"-Qoption ccfe -tmpldepth=128" ]
        [ run integer_mask_test.cpp ]
        [ run static_log2_test.cpp ]
        [ run static_min_max_test.cpp ]
        [ compile cstdint_include_test.cpp ]
        [ compile integer_traits_include_test.cpp ]
        [ compile integer_include_test.cpp ]
        [ compile integer_mask_include_test.cpp ]
        [ compile static_log2_include_test.cpp ]
        [ compile static_min_max_include_test.cpp ]
        [ compile integer_fwd_include_test.cpp ]
    ;
--- a/test/cstdint_include_test.cpp
+++ b/test/cstdint_include_test.cpp
@ -0,0 +1,69 @@
 //  Copyright John Maddock 2009.  
 //  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)
 #define __STDC_CONSTANT_MACROS
 #include <boost/cstdint.hpp> // must be the only #include!
 int main()
 {
   boost::int8_t i8 = INT8_C(0);
   (void)i8;
   boost::uint8_t ui8 = UINT8_C(0);
   (void)ui8;
   boost::int16_t i16 = INT16_C(0);
   (void)i16;
   boost::uint16_t ui16 = UINT16_C(0);
   (void)ui16;
   boost::int32_t i32 = INT32_C(0);
   (void)i32;
   boost::uint32_t ui32 = UINT32_C(0);
   (void)ui32;
 #ifndef BOOST_NO_INT64_T
   boost::int64_t i64 = 0;
   (void)i64;
   boost::uint64_t ui64 = 0;
   (void)ui64;
 #endif
   boost::int_least8_t i8least = INT8_C(0);
   (void)i8least;
   boost::uint_least8_t ui8least = UINT8_C(0);
   (void)ui8least;
   boost::int_least16_t i16least = INT16_C(0);
   (void)i16least;
   boost::uint_least16_t ui16least = UINT16_C(0);
   (void)ui16least;
   boost::int_least32_t i32least = INT32_C(0);
   (void)i32least;
   boost::uint_least32_t ui32least = UINT32_C(0);
   (void)ui32least;
 #ifndef BOOST_NO_INT64_T
   boost::int_least64_t i64least = 0;
   (void)i64least;
   boost::uint_least64_t ui64least = 0;
   (void)ui64least;
 #endif
   boost::int_fast8_t i8fast = INT8_C(0);
   (void)i8fast;
   boost::uint_fast8_t ui8fast = UINT8_C(0);
   (void)ui8fast;
   boost::int_fast16_t i16fast = INT16_C(0);
   (void)i16fast;
   boost::uint_fast16_t ui16fast = UINT16_C(0);
   (void)ui16fast;
   boost::int_fast32_t i32fast = INT32_C(0);
   (void)i32fast;
   boost::uint_fast32_t ui32fast = UINT32_C(0);
   (void)ui32fast;
 #ifndef BOOST_NO_INT64_T
   boost::int_fast64_t i64fast = 0;
   (void)i64fast;
   boost::uint_fast64_t ui64fast = 0;
   (void)ui64fast;
 #endif
   boost::intmax_t im = 0;
   (void)im;
   boost::uintmax_t uim = 0;
   (void)uim;
 }
--- a/test/cstdint_test.cpp
+++ b/test/cstdint_test.cpp
@ -1,36 +1,36 @@
 //  boost cstdint.hpp test program  ------------------------------------------//
-//  (C) Copyright Beman Dawes 2000. Permission to copy, use, modify, sell
+//  Copyright Beman Dawes 2000.  Distributed under the Boost
-//  and distribute this software is granted provided this copyright
+//  Software License, Version 1.0. (See accompanying file
-//  notice appears in all copies. This software is provided "as is" without
+//  LICENSE_1_0.txt or copy at 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.
+
 //  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
 #include <cassert>
 #include <iostream>
 #include <boost/cstdint.hpp>
 //
 // macros should not be defined by default:
 //
 #ifdef INT8_C
 #error header incorrectly implemented
 #endif
 //
 // now define the macros:
 //
 #define __STDC_CONSTANT_MACROS
 #include <boost/cstdint.hpp>
-#ifdef NDEBUG
+//
-#error This test makes no sense with NDEBUG defined
+// There are two ways to test this: in version 1, we include cstdint.hpp as the first
 // include, which means we get decide whether __STDC_CONSTANT_MACROS is defined.
 // In version two we include stdint.h with __STDC_CONSTANT_MACROS *NOT* defined first,
 // and check that we still end up with compatible definitions for the INT#_C macros.
 //
 // This is version 1.
 //
 #if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))
 // We can't suppress this warning on the command line as not all GCC versions support -Wno-type-limits :
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
 #include <boost/cstdint.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 //
 // the following class is designed to verify
@ -68,24 +68,24 @@ struct integral_constant_checker
 void integral_constant_checker::check()
 {
-  assert( int8 == -127 );
+  BOOST_TEST( int8 == -127 );
-  assert( int_least8 == -127 );
+  BOOST_TEST( int_least8 == -127 );
-  assert( int_fast8 == -127 );
+  BOOST_TEST( int_fast8 == -127 );
-  assert( uint8 == 255u );
+  BOOST_TEST( uint8 == 255u );
-  assert( uint_least8 == 255u );
+  BOOST_TEST( uint_least8 == 255u );
-  assert( uint_fast8 == 255u );
+  BOOST_TEST( uint_fast8 == 255u );
-  assert( int16 == -32767 );
+  BOOST_TEST( int16 == -32767 );
-  assert( int_least16 == -32767 );
+  BOOST_TEST( int_least16 == -32767 );
-  assert( int_fast16 == -32767 );
+  BOOST_TEST( int_fast16 == -32767 );
-  assert( uint16 == 65535u );
+  BOOST_TEST( uint16 == 65535u );
-  assert( uint_least16 == 65535u );
+  BOOST_TEST( uint_least16 == 65535u );
-  assert( uint_fast16 == 65535u );
+  BOOST_TEST( uint_fast16 == 65535u );
-  assert( int32 == -2147483647 );
+  BOOST_TEST( int32 == -2147483647 );
-  assert( int_least32 == -2147483647 );
+  BOOST_TEST( int_least32 == -2147483647 );
-  assert( int_fast32 == -2147483647 );
+  BOOST_TEST( int_fast32 == -2147483647 );
-  assert( uint32 == 4294967295u );
+  BOOST_TEST( uint32 == 4294967295u );
-  assert( uint_least32 == 4294967295u );
+  BOOST_TEST( uint_least32 == 4294967295u );
-  assert( uint_fast32 == 4294967295u );
+  BOOST_TEST( uint_fast32 == 4294967295u );
 }
 #endif // BOOST_NO_INCLASS_MEMBER_INITIALIZATION
@ -108,18 +108,39 @@ void integral_constant_type_check(T1, T2)
   // numeric_limits implementations currently
   // vary too much, or are incomplete or missing.
   //
-   assert(sizeof(T1) == sizeof(T2));
+   T1 t1 = static_cast<T1>(-1);  // cast suppresses warnings
-   T1 t1 = -1;
+   T2 t2 = static_cast<T2>(-1);  // ditto
-   T2 t2 = -1;
+#if defined(BOOST_HAS_STDINT_H)
-   assert(t1 == t2);
+   // if we have a native stdint.h
-   if(t1 >= 0)
+   // then the INTXX_C macros may define
-     assert(t2 >= 0);
+   // a type that's wider than required:
   BOOST_TEST(sizeof(T1) <= sizeof(T2));
 #else
   BOOST_TEST(sizeof(T1) == sizeof(T2));
   BOOST_TEST(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)
        BOOST_TEST(t2 > 0);
      else
        BOOST_TEST(!(t2 > 0));
   }
   else if(t1 < 0)
      BOOST_TEST(!(t2 > 0));
 #else
   if(t1 > 0)
     BOOST_TEST(t2 > 0);
   else
-     assert(t2 < 0);
+     BOOST_TEST(!(t2 > 0));
 #endif
 }
-int main()
+int main(int, char*[])
 {
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
  integral_constant_checker::check();
@ -178,50 +199,40 @@ int main()
  boost::uintmax_t       uintmax       = UINTMAX_C(4294967295);
 #endif
-  assert( int8 == -127 );
+  BOOST_TEST( int8 == -127 );
-  assert( int_least8 == -127 );
+  BOOST_TEST( int_least8 == -127 );
-  assert( int_fast8 == -127 );
+  BOOST_TEST( int_fast8 == -127 );
-  assert( uint8 == 255u );
+  BOOST_TEST( uint8 == 255u );
-  assert( uint_least8 == 255u );
+  BOOST_TEST( uint_least8 == 255u );
-  assert( uint_fast8 == 255u );
+  BOOST_TEST( uint_fast8 == 255u );
-  assert( int16 == -32767 );
+  BOOST_TEST( int16 == -32767 );
-  assert( int_least16 == -32767 );
+  BOOST_TEST( int_least16 == -32767 );
-  assert( int_fast16 == -32767 );
+  BOOST_TEST( int_fast16 == -32767 );
-  assert( uint16 == 65535u );
+  BOOST_TEST( uint16 == 65535u );
-  assert( uint_least16 == 65535u );
+  BOOST_TEST( uint_least16 == 65535u );
-  assert( uint_fast16 == 65535u );
+  BOOST_TEST( uint_fast16 == 65535u );
-  assert( int32 == -2147483647 );
+  BOOST_TEST( int32 == -2147483647 );
-  assert( int_least32 == -2147483647 );
+  BOOST_TEST( int_least32 == -2147483647 );
-  assert( int_fast32 == -2147483647 );
+  BOOST_TEST( int_fast32 == -2147483647 );
-  assert( uint32 == 4294967295u );
+  BOOST_TEST( uint32 == 4294967295u );
-  assert( uint_least32 == 4294967295u );
+  BOOST_TEST( uint_least32 == 4294967295u );
-  assert( uint_fast32 == 4294967295u );
+  BOOST_TEST( uint_fast32 == 4294967295u );
 #ifndef BOOST_NO_INT64_T
-  assert( int64 == INT64_C(-9223372036854775807) );
+  BOOST_TEST( int64 == INT64_C(-9223372036854775807) );
-  assert( int_least64 == INT64_C(-9223372036854775807) );
+  BOOST_TEST( int_least64 == INT64_C(-9223372036854775807) );
-  assert( int_fast64 == INT64_C(-9223372036854775807) );
+  BOOST_TEST( int_fast64 == INT64_C(-9223372036854775807) );
-  assert( uint64 == UINT64_C(18446744073709551615) );
+  BOOST_TEST( uint64 == UINT64_C(18446744073709551615) );
-  assert( uint_least64 == UINT64_C(18446744073709551615) );
+  BOOST_TEST( uint_least64 == UINT64_C(18446744073709551615) );
-  assert( uint_fast64 == UINT64_C(18446744073709551615) );
+  BOOST_TEST( uint_fast64 == UINT64_C(18446744073709551615) );
-  assert( intmax == INT64_C(-9223372036854775807) );
+  BOOST_TEST( intmax == INT64_C(-9223372036854775807) );
-  assert( uintmax == UINT64_C(18446744073709551615) );
+  BOOST_TEST( uintmax == UINT64_C(18446744073709551615) );
 #else
-  assert( intmax == -2147483647 );
+  BOOST_TEST( intmax == -2147483647 );
-  assert( uintmax == 4294967295u );
+  BOOST_TEST( uintmax == 4294967295u );
 #endif
  std::cout << "OK\n";
-  return 0;
+  return boost::report_errors();
 }
 //
 // now verify that constant macros get undef'ed correctly:
 //
 #undef __STDC_CONSTANT_MACROS
 #include <boost/cstdint.hpp>
 #ifdef INT8_C
 #error boost/cstdint.hpp not correctly defined
 #endif
--- a/test/cstdint_test2.cpp
+++ b/test/cstdint_test2.cpp
@ -0,0 +1,248 @@
 //  boost cstdint.hpp test program  ------------------------------------------//
 //  Copyright Beman Dawes 2000.  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
 //   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
 //
 // There are two ways to test this: in version 1, we include cstdint.hpp as the first
 // include, which means we get decide whether __STDC_CONSTANT_MACROS is defined.
 // In version two we include stdint.h with __STDC_CONSTANT_MACROS *NOT* defined first,
 // and check that we still end up with compatible definitions for the INT#_C macros.
 //
 // This is version 2.
 //
 #if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))
 // We can't suppress this warning on the command line as not all GCC versions support -Wno-type-limits :
 #pragma GCC diagnostic ignored "-Wtype-limits"
 #endif
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_STDINT_H
 #ifdef __hpux
 #  include <inttypes.h>
 #else
 #  include <stdint.h>
 #endif
 #endif
 #include <boost/cstdint.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 //
 // the following class is designed to verify
 // that the various INTXX_C macros can be used
 // in integral constant expressions:
 //
 struct integral_constant_checker
 {
  static const boost::int8_t          int8          = INT8_C(-127);
  static const boost::int_least8_t    int_least8    = INT8_C(-127);
  static const boost::int_fast8_t     int_fast8     = INT8_C(-127);
  static const boost::uint8_t         uint8         = UINT8_C(255);
  static const boost::uint_least8_t   uint_least8   = UINT8_C(255);
  static const boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
  static const boost::int16_t         int16         = INT16_C(-32767);
  static const boost::int_least16_t   int_least16   = INT16_C(-32767);
  static const boost::int_fast16_t    int_fast16    = INT16_C(-32767);
  static const boost::uint16_t        uint16         = UINT16_C(65535);
  static const boost::uint_least16_t  uint_least16   = UINT16_C(65535);
  static const boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
  static const boost::int32_t         int32         = INT32_C(-2147483647);
  static const boost::int_least32_t   int_least32   = INT32_C(-2147483647);
  static const boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
  static const boost::uint32_t        uint32        = UINT32_C(4294967295);
  static const boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
  static const boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
  static void check();
 };
 void integral_constant_checker::check()
 {
  BOOST_TEST( int8 == -127 );
  BOOST_TEST( int_least8 == -127 );
  BOOST_TEST( int_fast8 == -127 );
  BOOST_TEST( uint8 == 255u );
  BOOST_TEST( uint_least8 == 255u );
  BOOST_TEST( uint_fast8 == 255u );
  BOOST_TEST( int16 == -32767 );
  BOOST_TEST( int_least16 == -32767 );
  BOOST_TEST( int_fast16 == -32767 );
  BOOST_TEST( uint16 == 65535u );
  BOOST_TEST( uint_least16 == 65535u );
  BOOST_TEST( uint_fast16 == 65535u );
  BOOST_TEST( int32 == -2147483647 );
  BOOST_TEST( int_least32 == -2147483647 );
  BOOST_TEST( int_fast32 == -2147483647 );
  BOOST_TEST( uint32 == 4294967295u );
  BOOST_TEST( uint_least32 == 4294967295u );
  BOOST_TEST( uint_fast32 == 4294967295u );
 }
 #endif // BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 //
 // the following function simply verifies that the type
 // of an integral constant is correctly defined:
 //
 #ifdef __BORLANDC__
 #pragma option -w-8008
 #pragma option -w-8066
 #endif
 template <class T1, class T2>
 void integral_constant_type_check(T1, T2)
 {
   //
   // the types T1 and T2 may not be exactly
   // the same type, but they should be the
   // same size and signedness. We could use
   // numeric_limits to verify this, but
   // numeric_limits implementations currently
   // vary too much, or are incomplete or missing.
   //
   T1 t1 = static_cast<T1>(-1);  // cast suppresses warnings
   T2 t2 = static_cast<T2>(-1);  // ditto
 #if defined(BOOST_HAS_STDINT_H)
   // if we have a native stdint.h
   // then the INTXX_C macros may define
   // a type that's wider than required:
   BOOST_TEST(sizeof(T1) <= sizeof(T2));
 #else
   BOOST_TEST(sizeof(T1) == sizeof(T2));
   BOOST_TEST(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)
        BOOST_TEST(t2 > 0);
      else
        BOOST_TEST(!(t2 > 0));
   }
   else if(t1 < 0)
      BOOST_TEST(!(t2 > 0));
 #else
   if(t1 > 0)
     BOOST_TEST(t2 > 0);
   else
     BOOST_TEST(!(t2 > 0));
 #endif
 }
 int main(int, char*[])
 {
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
  integral_constant_checker::check();
 #endif
  //
  // verify the types of the integral constants:
  //
  integral_constant_type_check(boost::int8_t(0), INT8_C(0));
  integral_constant_type_check(boost::uint8_t(0), UINT8_C(0));
  integral_constant_type_check(boost::int16_t(0), INT16_C(0));
  integral_constant_type_check(boost::uint16_t(0), UINT16_C(0));
  integral_constant_type_check(boost::int32_t(0), INT32_C(0));
  integral_constant_type_check(boost::uint32_t(0), UINT32_C(0));
 #ifndef BOOST_NO_INT64_T
  integral_constant_type_check(boost::int64_t(0), INT64_C(0));
  integral_constant_type_check(boost::uint64_t(0), UINT64_C(0));
 #endif
  //
  boost::int8_t          int8          = INT8_C(-127);
  boost::int_least8_t    int_least8    = INT8_C(-127);
  boost::int_fast8_t     int_fast8     = INT8_C(-127);
  boost::uint8_t         uint8         = UINT8_C(255);
  boost::uint_least8_t   uint_least8   = UINT8_C(255);
  boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
  boost::int16_t         int16         = INT16_C(-32767);
  boost::int_least16_t   int_least16   = INT16_C(-32767);
  boost::int_fast16_t    int_fast16    = INT16_C(-32767);
  boost::uint16_t        uint16         = UINT16_C(65535);
  boost::uint_least16_t  uint_least16   = UINT16_C(65535);
  boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
  boost::int32_t         int32         = INT32_C(-2147483647);
  boost::int_least32_t   int_least32   = INT32_C(-2147483647);
  boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
  boost::uint32_t        uint32        = UINT32_C(4294967295);
  boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
  boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
 #ifndef BOOST_NO_INT64_T
  boost::int64_t         int64         = INT64_C(-9223372036854775807);
  boost::int_least64_t   int_least64   = INT64_C(-9223372036854775807);
  boost::int_fast64_t    int_fast64    = INT64_C(-9223372036854775807);
  boost::uint64_t        uint64        = UINT64_C(18446744073709551615);
  boost::uint_least64_t  uint_least64  = UINT64_C(18446744073709551615);
  boost::uint_fast64_t   uint_fast64   = UINT64_C(18446744073709551615);
  boost::intmax_t        intmax        = INTMAX_C(-9223372036854775807);
  boost::uintmax_t       uintmax       = UINTMAX_C(18446744073709551615);
 #else
  boost::intmax_t        intmax        = INTMAX_C(-2147483647);
  boost::uintmax_t       uintmax       = UINTMAX_C(4294967295);
 #endif
  BOOST_TEST( int8 == -127 );
  BOOST_TEST( int_least8 == -127 );
  BOOST_TEST( int_fast8 == -127 );
  BOOST_TEST( uint8 == 255u );
  BOOST_TEST( uint_least8 == 255u );
  BOOST_TEST( uint_fast8 == 255u );
  BOOST_TEST( int16 == -32767 );
  BOOST_TEST( int_least16 == -32767 );
  BOOST_TEST( int_fast16 == -32767 );
  BOOST_TEST( uint16 == 65535u );
  BOOST_TEST( uint_least16 == 65535u );
  BOOST_TEST( uint_fast16 == 65535u );
  BOOST_TEST( int32 == -2147483647 );
  BOOST_TEST( int_least32 == -2147483647 );
  BOOST_TEST( int_fast32 == -2147483647 );
  BOOST_TEST( uint32 == 4294967295u );
  BOOST_TEST( uint_least32 == 4294967295u );
  BOOST_TEST( uint_fast32 == 4294967295u );
 #ifndef BOOST_NO_INT64_T
  BOOST_TEST( int64 == INT64_C(-9223372036854775807) );
  BOOST_TEST( int_least64 == INT64_C(-9223372036854775807) );
  BOOST_TEST( int_fast64 == INT64_C(-9223372036854775807) );
  BOOST_TEST( uint64 == UINT64_C(18446744073709551615) );
  BOOST_TEST( uint_least64 == UINT64_C(18446744073709551615) );
  BOOST_TEST( uint_fast64 == UINT64_C(18446744073709551615) );
  BOOST_TEST( intmax == INT64_C(-9223372036854775807) );
  BOOST_TEST( uintmax == UINT64_C(18446744073709551615) );
 #else
  BOOST_TEST( intmax == -2147483647 );
  BOOST_TEST( uintmax == 4294967295u );
 #endif
  std::cout << "OK\n";
  return boost::report_errors();
 }
--- a/test/integer_fwd_include_test.cpp
+++ b/test/integer_fwd_include_test.cpp
@ -0,0 +1,22 @@
 //  Copyright John Maddock 2009.  
 //  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)
 #include <boost/integer_fwd.hpp> // must be the only #include!
 // just declare some functions that use the incomplete types in the header:
 void f1(const boost::integer_traits<char>*);
 void f2(const boost::int_fast_t<char>*);
 void f3(const boost::int_t<12>*);
 void f4(const boost::uint_t<31>*);
 void f5(const boost::int_max_value_t<100>*);
 void f6(const boost::int_min_value_t<-100>*);
 void f7(const boost::uint_value_t<100>*);
 void f8(const boost::high_bit_mask_t<10>*);
 void f9(const boost::low_bits_mask_t<10>*);
 void f10(boost::static_log2_argument_type, boost::static_log2_result_type, boost::static_log2<10>*);
 void f11(boost::static_min_max_signed_type, boost::static_min_max_unsigned_type);
 void f12(boost::static_signed_min<1, 2>*, boost::static_signed_max<1,2>*);
 void f13(boost::static_unsigned_min<1,2>*, boost::static_unsigned_min<1,2>*);
--- a/test/integer_include_test.cpp
+++ b/test/integer_include_test.cpp
@ -0,0 +1,36 @@
 //  Copyright John Maddock 2009.  
 //  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)
 #include <boost/integer.hpp> // must be the only #include!
 int main()
 {
   boost::int_fast_t<char>::fast f = 0;
   (void)f;
   boost::int_t<16>::fast f2 = 0;
   (void)f2;
   boost::int_t<32>::exact e = 0;
   (void)e;
   boost::int_t<12>::least l = 0;
   (void)l;
   boost::uint_t<16>::fast uf2 = 0;
   (void)uf2;
   boost::uint_t<32>::exact ue = 0;
   (void)ue;
   boost::uint_t<12>::least ul = 0;
   (void)ul;
   boost::int_max_value_t<200>::fast v1 = 0;
   (void)v1;
   boost::int_max_value_t<2000>::least v2 = 0;
   (void)v2;
   boost::int_min_value_t<-200>::fast v3 = 0;
   (void)v3;
   boost::int_min_value_t<-2000>::least v4 = 0;
   (void)v4;
   boost::uint_value_t<200>::fast v5 = 0;
   (void)v5;
   boost::uint_value_t<2000>::least v6 = 0;
   (void)v6;
 }
--- a/test/integer_mask_include_test.cpp
+++ b/test/integer_mask_include_test.cpp
@ -0,0 +1,18 @@
 //  Copyright John Maddock 2009.  
 //  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)
 #include <boost/integer/integer_mask.hpp> // must be the only #include!
 int main()
 {
   boost::high_bit_mask_t<20>::least l = boost::high_bit_mask_t<20>::high_bit;
   boost::high_bit_mask_t<12>::fast f = boost::high_bit_mask_t<12>::high_bit_fast;
   l += f + boost::high_bit_mask_t<12>::bit_position;
   (void)l;
   boost::low_bits_mask_t<20>::least l2 = boost::low_bits_mask_t<20>::sig_bits;
   boost::low_bits_mask_t<12>::fast f2 = boost::low_bits_mask_t<12>::sig_bits_fast;
   l2 += f2 + boost::low_bits_mask_t<12>::bit_count;
   (void)l2;
 }
--- a/test/integer_mask_test.cpp
+++ b/test/integer_mask_test.cpp
@ -0,0 +1,203 @@
 //  boost integer_mask.hpp test program  -------------------------------------//
 //  (C) Copyright Daryle Walker 2001.
 //  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 for most recent version including documentation.
 //  Revision History
 //  23 Sep 2001  Initial version (Daryle Walker)
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/cstdlib.hpp>               // for boost::exit_success
 #include <boost/integer/integer_mask.hpp>  // for boost::high_bit_mask_t, etc.
 #include <iostream>  // for std::cout (std::endl indirectly)
 #ifdef BOOST_MSVC
 #pragma warning(disable:4127) // conditional expression is constant
 #endif
 #if defined(BOOST_HAS_LONG_LONG)
 #define MASK_TYPE ::boost::ulong_long_type
 #elif defined(BOOST_HAS_MS_INT64)
 #define MASK_TYPE unsigned __int64
 #else
 #define MASK_TYPE unsigned long
 #endif
 #define ONE (static_cast<MASK_TYPE>(1))
 #define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
 (v) >::high_bit == (ONE << (v)) );
 #define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
 (v) >::high_bit_fast == (ONE << (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)  \
   do{ \
      MASK_TYPE mask = 0;\
      if(v > 0)\
         { mask = ((ONE << (v-1)) - 1); mask <<= 1; mask |= 1; }\
      BOOST_TEST( ::boost::low_bits_mask_t< (v) >::sig_bits ==  mask); \
   }while(false);
 #define PRIVATE_LOW_BITS_FAST_TEST(v)  \
   do{ \
      MASK_TYPE mask = 0;\
      if(v > 0)\
         { mask = ((ONE << (v-1)) - 1); mask <<= 1; mask |= 1; }\
      BOOST_TEST( ::boost::low_bits_mask_t< (v) >::sig_bits_fast == mask);\
   }while(false);
 #define PRIVATE_LOW_BITS_TEST(v)  do { PRIVATE_LOW_BITS_SLOW_TEST(v); \
 PRIVATE_LOW_BITS_FAST_TEST(v); } while (false)
 int main( int, char*[] )
 {
    using std::cout;
    using std::endl;
    cout << "Doing high_bit_mask_t tests." << endl;
 #if defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)
    PRIVATE_HIGH_BIT_TEST( 63 );
    PRIVATE_HIGH_BIT_TEST( 62 );
    PRIVATE_HIGH_BIT_TEST( 61 );
    PRIVATE_HIGH_BIT_TEST( 60 );
    PRIVATE_HIGH_BIT_TEST( 59 );
    PRIVATE_HIGH_BIT_TEST( 58 );
    PRIVATE_HIGH_BIT_TEST( 57 );
    PRIVATE_HIGH_BIT_TEST( 56 );
    PRIVATE_HIGH_BIT_TEST( 55 );
    PRIVATE_HIGH_BIT_TEST( 54 );
    PRIVATE_HIGH_BIT_TEST( 53 );
    PRIVATE_HIGH_BIT_TEST( 52 );
    PRIVATE_HIGH_BIT_TEST( 51 );
    PRIVATE_HIGH_BIT_TEST( 50 );
    PRIVATE_HIGH_BIT_TEST( 49 );
    PRIVATE_HIGH_BIT_TEST( 48 );
    PRIVATE_HIGH_BIT_TEST( 47 );
    PRIVATE_HIGH_BIT_TEST( 46 );
    PRIVATE_HIGH_BIT_TEST( 45 );
    PRIVATE_HIGH_BIT_TEST( 44 );
    PRIVATE_HIGH_BIT_TEST( 43 );
    PRIVATE_HIGH_BIT_TEST( 42 );
    PRIVATE_HIGH_BIT_TEST( 41 );
    PRIVATE_HIGH_BIT_TEST( 40 );
    PRIVATE_HIGH_BIT_TEST( 39 );
    PRIVATE_HIGH_BIT_TEST( 38 );
    PRIVATE_HIGH_BIT_TEST( 37 );
    PRIVATE_HIGH_BIT_TEST( 36 );
    PRIVATE_HIGH_BIT_TEST( 35 );
    PRIVATE_HIGH_BIT_TEST( 34 );
    PRIVATE_HIGH_BIT_TEST( 33 );
    PRIVATE_HIGH_BIT_TEST( 32 );
 #endif
    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 );
    cout << "Doing low_bits_mask_t tests." << endl;
 #if defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)
    PRIVATE_LOW_BITS_TEST( 64 );
    PRIVATE_LOW_BITS_TEST( 63 );
    PRIVATE_LOW_BITS_TEST( 62 );
    PRIVATE_LOW_BITS_TEST( 61 );
    PRIVATE_LOW_BITS_TEST( 60 );
    PRIVATE_LOW_BITS_TEST( 59 );
    PRIVATE_LOW_BITS_TEST( 58 );
    PRIVATE_LOW_BITS_TEST( 57 );
    PRIVATE_LOW_BITS_TEST( 56 );
    PRIVATE_LOW_BITS_TEST( 55 );
    PRIVATE_LOW_BITS_TEST( 54 );
    PRIVATE_LOW_BITS_TEST( 53 );
    PRIVATE_LOW_BITS_TEST( 52 );
    PRIVATE_LOW_BITS_TEST( 51 );
    PRIVATE_LOW_BITS_TEST( 50 );
    PRIVATE_LOW_BITS_TEST( 49 );
    PRIVATE_LOW_BITS_TEST( 48 );
    PRIVATE_LOW_BITS_TEST( 47 );
    PRIVATE_LOW_BITS_TEST( 46 );
    PRIVATE_LOW_BITS_TEST( 45 );
    PRIVATE_LOW_BITS_TEST( 44 );
    PRIVATE_LOW_BITS_TEST( 43 );
    PRIVATE_LOW_BITS_TEST( 42 );
    PRIVATE_LOW_BITS_TEST( 41 );
    PRIVATE_LOW_BITS_TEST( 40 );
    PRIVATE_LOW_BITS_TEST( 39 );
    PRIVATE_LOW_BITS_TEST( 38 );
    PRIVATE_LOW_BITS_TEST( 37 );
    PRIVATE_LOW_BITS_TEST( 36 );
    PRIVATE_LOW_BITS_TEST( 35 );
    PRIVATE_LOW_BITS_TEST( 34 );
    PRIVATE_LOW_BITS_TEST( 33 );
 #endif
    PRIVATE_LOW_BITS_TEST( 32 );
    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 );
    return boost::report_errors();
 }
--- a/test/integer_test.cpp
+++ b/test/integer_test.cpp
@ -0,0 +1,263 @@
 //  boost integer.hpp test program  ------------------------------------------//
 //  Copyright Beman Dawes 1999.  
 //  Copyright Daryle Walker 2001.  
 //  Copyright John Maddock 2009.  
 //  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
 //   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
 #include <boost/detail/lightweight_test.hpp>  // for main, BOOST_TEST
 #include <boost/integer.hpp>  // for boost::int_t, boost::uint_t
 #include <boost/type_traits/is_same.hpp>
 #include <climits>   // for ULONG_MAX, LONG_MAX, LONG_MIN
 #include <iostream>  // for std::cout (std::endl indirectly)
 #include <typeinfo>  // for std::type_info
 #ifdef BOOST_MSVC
 #pragma warning(disable:4127) // conditional expression is constant
 #endif
 #if defined( __BORLANDC__ )
 # pragma option -w-8008 -w-8066 // condition is always true
 #endif
 //
 // Keep track of error count, so we can print out detailed
 // info only if we need it:
 //
 int last_error_count = 0;
 //
 // Helpers to print out the name of a type,
 // we use these as typeid(X).name() doesn't always
 // return a human readable string:
 //
 template <class T> const char* get_name_of_type(T){ return typeid(T).name(); }
 const char* get_name_of_type(signed char){ return "signed char"; }
 const char* get_name_of_type(unsigned char){ return "unsigned char"; }
 const char* get_name_of_type(short){ return "short"; }
 const char* get_name_of_type(unsigned short){ return "unsigned short"; }
 const char* get_name_of_type(int){ return "int"; }
 const char* get_name_of_type(unsigned int){ return "unsigned int"; }
 const char* get_name_of_type(long){ return "long"; }
 const char* get_name_of_type(unsigned long){ return "unsigned long"; }
 #ifdef BOOST_HAS_LONG_LONG
 const char* get_name_of_type(boost::long_long_type){ return "boost::long_long_type"; }
 const char* get_name_of_type(boost::ulong_long_type){ return "boost::ulong_long_type"; }
 #endif
 template <int Bits>
 void do_test_exact(boost::mpl::true_ const&)
 {
   // Test the ::exact member:
   typedef typename boost::int_t<Bits>::exact int_exact;
   typedef typename boost::uint_t<Bits>::exact uint_exact;
   typedef typename boost::int_t<Bits>::least least_int;
   typedef typename boost::uint_t<Bits>::least least_uint;
   BOOST_TEST((boost::is_same<int_exact, least_int>::value));
   BOOST_TEST((boost::is_same<uint_exact, least_uint>::value));
 }
 template <int Bits>
 void do_test_exact(boost::mpl::false_ const&)
 {
   // Nothing to do, type does not have an ::extact member.
 }
 template <int Bits>
 void do_test_bits()
 {
   //
   // Recurse to next smallest number of bits:
   //
   do_test_bits<Bits - 1>();
   //
   // Test exact types if we have them:
   //
   do_test_exact<Bits>(
      boost::mpl::bool_<
      (sizeof(unsigned char) * CHAR_BIT == Bits)
      || (sizeof(unsigned short) * CHAR_BIT == Bits)
      || (sizeof(unsigned int) * CHAR_BIT == Bits)
      || (sizeof(unsigned long) * CHAR_BIT == Bits)
 #ifdef BOOST_HAS_LONG_LONG
      || (sizeof(boost::ulong_long_type) * CHAR_BIT == Bits)
 #endif
      >());
   //
   // We need to check all aspects of the members of int_t<Bits> and uint_t<Bits>:
   //
   typedef typename boost::int_t<Bits>::least least_int;
   typedef typename boost::int_t<Bits>::least fast_int;
   typedef typename boost::uint_t<Bits>::least least_uint;
   typedef typename boost::uint_t<Bits>::fast fast_uint;
   if(std::numeric_limits<least_int>::is_specialized)
   {
      BOOST_TEST(std::numeric_limits<least_int>::digits + 1 >= Bits);
   }
   if(std::numeric_limits<least_uint>::is_specialized)
   {
      BOOST_TEST(std::numeric_limits<least_uint>::digits >= Bits);
   }
   BOOST_TEST(sizeof(least_int) * CHAR_BIT >= Bits);
   BOOST_TEST(sizeof(least_uint) * CHAR_BIT >= Bits);
   BOOST_TEST(sizeof(fast_int) >= sizeof(least_int));
   BOOST_TEST(sizeof(fast_uint) >= sizeof(least_uint));
   //
   // There should be no type smaller than least_* that also has enough bits:
   //
   if(!boost::is_same<signed char, least_int>::value)
   {
      BOOST_TEST(std::numeric_limits<signed char>::digits < Bits);
      if(!boost::is_same<short, least_int>::value)
      {
         BOOST_TEST(std::numeric_limits<short>::digits < Bits);
         if(!boost::is_same<int, least_int>::value)
         {
            BOOST_TEST(std::numeric_limits<int>::digits < Bits);
            if(!boost::is_same<long, least_int>::value)
            {
               BOOST_TEST(std::numeric_limits<long>::digits < Bits);
            }
         }
      }
   }
   // And again, but unsigned:
   if(!boost::is_same<unsigned char, least_uint>::value)
   {
      BOOST_TEST(std::numeric_limits<unsigned char>::digits < Bits);
      if(!boost::is_same<unsigned short, least_uint>::value)
      {
         BOOST_TEST(std::numeric_limits<unsigned short>::digits < Bits);
         if(!boost::is_same<unsigned int, least_uint>::value)
         {
            BOOST_TEST(std::numeric_limits<unsigned int>::digits < Bits);
            if(!boost::is_same<unsigned long, least_uint>::value)
            {
               BOOST_TEST(std::numeric_limits<unsigned long>::digits < Bits);
            }
         }
      }
   }
   if(boost::detail::test_errors() != last_error_count)
   {
      last_error_count = boost::detail::test_errors();
      std::cout << "Errors occurred while testing with bit count = " << Bits << std::endl;
      std::cout << "Type int_t<" << Bits << ">::least was " << get_name_of_type(least_int(0)) << std::endl;
      std::cout << "Type int_t<" << Bits << ">::fast was " << get_name_of_type(fast_int(0)) << std::endl;
      std::cout << "Type uint_t<" << Bits << ">::least was " << get_name_of_type(least_uint(0)) << std::endl;
      std::cout << "Type uint_t<" << Bits << ">::fast was " << get_name_of_type(fast_uint(0)) << std::endl;
   }
 }
 template <>
 void do_test_bits<-1>()
 {
   // Nothing to do here!!
 }
 template <class Traits, class Expected>
 void test_min_max_type(Expected val)
 {
   typedef typename Traits::least least_type;
   typedef typename Traits::fast  fast_type;
   BOOST_TEST((boost::is_same<least_type, Expected>::value));
   BOOST_TEST(sizeof(fast_type) >= sizeof(least_type));
   BOOST_TEST((std::numeric_limits<least_type>::min)() <= val);
   BOOST_TEST((std::numeric_limits<least_type>::max)() >= val);
   if(boost::detail::test_errors() != last_error_count)
   {
      last_error_count = boost::detail::test_errors();
      std::cout << "Traits type is: " << typeid(Traits).name() << std::endl;
      std::cout << "Least type is: " << get_name_of_type(least_type(0)) << std::endl;
      std::cout << "Fast type is: " << get_name_of_type(fast_type(0)) << std::endl;
      std::cout << "Expected type is: " << get_name_of_type(Expected(0)) << std::endl;
      std::cout << "Required value is: " << val << std::endl;
   }
 }
 // Test program
 int main(int, char*[])
 {
   // Test int_t and unint_t first:
   if(std::numeric_limits<boost::intmax_t>::is_specialized)
      do_test_bits<std::numeric_limits<boost::uintmax_t>::digits>();
   else
      do_test_bits<std::numeric_limits<long>::digits>();
   //
   // Test min and max value types:
   //
   test_min_max_type<boost::int_max_value_t<SCHAR_MAX>, signed char>(SCHAR_MAX);
   test_min_max_type<boost::int_min_value_t<SCHAR_MIN>, signed char>(SCHAR_MIN);
   test_min_max_type<boost::uint_value_t<UCHAR_MAX>, unsigned char>(UCHAR_MAX);
 #if(USHRT_MAX != UCHAR_MAX)
      test_min_max_type<boost::int_max_value_t<SCHAR_MAX+1>, short>(SCHAR_MAX+1);
      test_min_max_type<boost::int_min_value_t<SCHAR_MIN-1>, short>(SCHAR_MIN-1);
      test_min_max_type<boost::uint_value_t<UCHAR_MAX+1>, unsigned short>(UCHAR_MAX+1);
      test_min_max_type<boost::int_max_value_t<SHRT_MAX>, short>(SHRT_MAX);
      test_min_max_type<boost::int_min_value_t<SHRT_MIN>, short>(SHRT_MIN);
      test_min_max_type<boost::uint_value_t<USHRT_MAX>, unsigned short>(USHRT_MAX);
 #endif
 #if(UINT_MAX != USHRT_MAX)
      test_min_max_type<boost::int_max_value_t<SHRT_MAX+1>, int>(SHRT_MAX+1);
      test_min_max_type<boost::int_min_value_t<SHRT_MIN-1>, int>(SHRT_MIN-1);
      test_min_max_type<boost::uint_value_t<USHRT_MAX+1>, unsigned int>(USHRT_MAX+1);
      test_min_max_type<boost::int_max_value_t<INT_MAX>, int>(INT_MAX);
      test_min_max_type<boost::int_min_value_t<INT_MIN>, int>(INT_MIN);
      test_min_max_type<boost::uint_value_t<UINT_MAX>, unsigned int>(UINT_MAX);
 #endif
 #if(ULONG_MAX != UINT_MAX)
      test_min_max_type<boost::int_max_value_t<INT_MAX+1L>, long>(INT_MAX+1L);
      test_min_max_type<boost::int_min_value_t<INT_MIN-1L>, long>(INT_MIN-1L);
      test_min_max_type<boost::uint_value_t<UINT_MAX+1uL>, unsigned long>(UINT_MAX+1uL);
      test_min_max_type<boost::int_max_value_t<LONG_MAX>, long>(LONG_MAX);
      test_min_max_type<boost::int_min_value_t<LONG_MIN>, long>(LONG_MIN);
      test_min_max_type<boost::uint_value_t<ULONG_MAX>, unsigned long>(ULONG_MAX);
 #endif
 #ifndef BOOST_NO_INTEGRAL_INT64_T
 #if defined(BOOST_HAS_LONG_LONG) && (defined(ULLONG_MAX) && (ULLONG_MAX != ULONG_MAX))
      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
      test_min_max_type<boost::int_max_value_t<LLONG_MAX>, boost::long_long_type>(LLONG_MAX);
      test_min_max_type<boost::int_min_value_t<LLONG_MIN>, boost::long_long_type>(LLONG_MIN);
      test_min_max_type<boost::uint_value_t<ULLONG_MAX>, boost::ulong_long_type>(ULLONG_MAX);
 #endif
 #if defined(BOOST_HAS_LONG_LONG) && (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX != ULONG_MAX))
      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
      test_min_max_type<boost::int_max_value_t<LONG_LONG_MAX>, boost::long_long_type>(LONG_LONG_MAX);
      test_min_max_type<boost::int_min_value_t<LONG_LONG_MIN>, boost::long_long_type>(LONG_LONG_MIN);
      test_min_max_type<boost::uint_value_t<ULONG_LONG_MAX>, boost::ulong_long_type>(ULONG_LONG_MAX);
 #endif
 #if defined(BOOST_HAS_LONG_LONG) && (defined(ULONGLONG_MAX) && (ULONGLONG_MAX != ULONG_MAX))
      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
      test_min_max_type<boost::int_max_value_t<LONGLONG_MAX>, boost::long_long_type>(LONGLONG_MAX);
      test_min_max_type<boost::int_min_value_t<LONGLONG_MIN>, boost::long_long_type>(LONGLONG_MAX);
      test_min_max_type<boost::uint_value_t<ULONGLONG_MAX>, boost::ulong_long_type>(ULONGLONG_MAX);
 #endif
 #if defined(BOOST_HAS_LONG_LONG) && (defined(_ULLONG_MAX) && defined(_LLONG_MIN) && (_ULLONG_MAX != ULONG_MAX))
      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
      test_min_max_type<boost::int_max_value_t<_LLONG_MAX>, boost::long_long_type>(_LLONG_MAX);
      test_min_max_type<boost::int_min_value_t<_LLONG_MIN>, boost::long_long_type>(_LLONG_MIN);
      test_min_max_type<boost::uint_value_t<_ULLONG_MAX>, boost::ulong_long_type>(_ULLONG_MAX);
 #endif // BOOST_HAS_LONG_LONG
 #endif // BOOST_NO_INTEGRAL_INT64_T
      return boost::report_errors();
 }
--- a/test/integer_traits_include_test.cpp
+++ b/test/integer_traits_include_test.cpp
@ -0,0 +1,37 @@
 //  Copyright John Maddock 2009.  
 //  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)
 #include <boost/integer_traits.hpp> // must be the only #include!
 template <class T>
 void check_numeric_limits_derived(const std::numeric_limits<T>&){}
 template <class T>
 void check()
 {
   typedef boost::integer_traits<T> traits;
   check_numeric_limits_derived(traits());
   bool b = traits::is_integral;
   (void)b;
   T v = traits::const_min + traits::const_max;
   (void)v;
 }
 int main()
 {
   check<signed char>();
   check<unsigned char>();
   check<char>();
   check<short>();
   check<unsigned short>();
   check<int>();
   check<unsigned int>();
   check<signed long>();
   check<unsigned long>();
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
   check<boost::long_long_type>();
   check<boost::ulong_long_type>();
 #endif
 }
--- a/test/integer_traits_test.cpp
+++ b/test/integer_traits_test.cpp
@ -1,14 +1,9 @@
 /* boost integer_traits.hpp tests
 *
 * Copyright Jens Maurer 2000
- * Permission to use, copy, modify, sell, and distribute this software
+ * Distributed under the Boost Software License, Version 1.0. (See
- * is hereby granted without free provided that the above copyright notice
+ * accompanying file LICENSE_1_0.txt or copy at
- * appears in all copies and that both that copyright notice and this
+ * http://www.boost.org/LICENSE_1_0.txt)
 * 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$
 *
@ -22,8 +17,7 @@
 // use int64_t instead of long long for better portability
 #include <boost/cstdint.hpp>
-#define BOOST_INCLUDE_MAIN
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/test/test_tools.hpp>
 /*
 * General portability note:
@ -35,22 +29,45 @@
 * Therefore, avoid explicit function template instantiations.
 */
 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 template<typename T> inline T make_char_numeric_for_streaming(T x) { return x; }
 namespace fix{
 inline int make_char_numeric_for_streaming(char c) { return c; }
 inline int make_char_numeric_for_streaming(signed char c) { return c; }
 inline int make_char_numeric_for_streaming(unsigned char c) { return c; }
 }
 using namespace fix;
 #else
 template<typename T> inline T make_char_numeric_for_streaming(T x) { return x; }
 inline int make_char_numeric_for_streaming(char c) { return c; }
 inline int make_char_numeric_for_streaming(signed char c) { return c; }
 inline int make_char_numeric_for_streaming(unsigned char c) { return c; }
 #endif
 template<class T>
 void runtest(const char * type, T)
 {
  typedef boost::integer_traits<T> traits;
  std::cout << "Checking " << type
-	    << "; min is " << traits::min()
+            << "; min is " << make_char_numeric_for_streaming((traits::min)())
-            << ", max is " << traits::max()
+            << ", max is " << make_char_numeric_for_streaming((traits::max)())
-	    << std::endl;
+            << std::endl;
  BOOST_TEST(traits::is_specialized);
 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
  // MSVC++ 6.0 issues a LNK1179 error (duplicate comdat) when the compiler
  // generates different symbol names with a very long common prefix:
  // the dummy "&& true" disambiguates between the symbols generated by this
  // BOOST_TEST instantiation and the preceding one.
  BOOST_TEST(traits::is_integer && true);
 #else
  BOOST_TEST(traits::is_integer);
-  BOOST_TEST(traits::is_integral);
+#endif
-  BOOST_TEST(traits::const_min == traits::min());
+  BOOST_TEST(traits::is_integral == true);
-  BOOST_TEST(traits::const_max == traits::max());
+  BOOST_TEST(traits::const_min == (traits::min)());
  BOOST_TEST(traits::const_max == (traits::max)());
 }
-int test_main(int, char*[])
+int main(int, char*[])
 {
  runtest("bool", bool());
  runtest("char", char());
@ -68,7 +85,7 @@ int test_main(int, char*[])
  runtest("long", long());
  typedef unsigned long unsigned_long;
  runtest("unsigned long", unsigned_long());
-#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_MSVC) && !defined(__BORLANDC__) && !defined(__BEOS__)
+#ifndef BOOST_NO_INTEGRAL_INT64_T
  //
  // MS/Borland compilers can't support 64-bit member constants
  // BeOS doesn't have specialisations for long long in SGI's <limits> header.
@ -79,6 +96,6 @@ int test_main(int, char*[])
 #endif
  // Some compilers don't pay attention to std:3.6.1/5 and issue a
  // warning here if "return 0;" is omitted.
-  return 0;
+  return boost::report_errors();
 }
--- a/test/static_log2_include_test.cpp
+++ b/test/static_log2_include_test.cpp
@ -0,0 +1,14 @@
 //  Copyright John Maddock 2009.  
 //  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)
 #include <boost/integer/static_log2.hpp> // must be the only #include!
 int main()
 {
   boost::static_log2_argument_type arg = 0;
   (void)arg;
   boost::static_log2_result_type result = boost::static_log2<30>::value;
   (void)result;
 }
--- a/test/static_log2_test.cpp
+++ b/test/static_log2_test.cpp
@ -0,0 +1,149 @@
 //  Boost static_log2.hpp test program  --------------------------------------//
 //  (C) Copyright Daryle Walker 2001.
 //  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 for most recent version including documentation.
 //  Revision History
 //  01 Oct 2001  Initial version (Daryle Walker)
 #include <boost/detail/lightweight_test.hpp>  // for main
 #include <boost/cstdlib.hpp>              // for boost::exit_success
 #include <boost/integer/static_log2.hpp>  // for boost::static_log2
 #include <iostream>  // for std::cout (std::endl indirectly)
 // Macros to compact code
 #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
 // Control to check for a compile-time error
 #ifndef CONTROL_LB_0_TEST
 #define PRIVATE_LB_0_TEST
 #else
 #define PRIVATE_LB_0_TEST  PRIVATE_PRINT_LB( 0 )
 #endif
 // Main testing function
 int
 main
 (
    int         ,   // "argc" is unused
    char *      []  // "argv" is unused
 )
 {    
    std::cout << "Doing tests on static_log2." << std::endl;
    PRIVATE_LB_0_TEST;
    PRIVATE_LB_TEST( 1, 0 );
    PRIVATE_LB_TEST( 2, 1 );
    PRIVATE_LB_TEST( 3, 1 );
    PRIVATE_LB_TEST( 4, 2 );
    PRIVATE_LB_TEST( 5, 2 );
    PRIVATE_LB_TEST( 6, 2 );
    PRIVATE_LB_TEST( 7, 2 );
    PRIVATE_LB_TEST(  8, 3 );
    PRIVATE_LB_TEST(  9, 3 );
    PRIVATE_LB_TEST( 10, 3 );
    PRIVATE_LB_TEST( 11, 3 );
    PRIVATE_LB_TEST( 12, 3 );
    PRIVATE_LB_TEST( 13, 3 );
    PRIVATE_LB_TEST( 14, 3 );
    PRIVATE_LB_TEST( 15, 3 );
    PRIVATE_LB_TEST( 16, 4 );
    PRIVATE_LB_TEST( 17, 4 );
    PRIVATE_LB_TEST( 18, 4 );
    PRIVATE_LB_TEST( 19, 4 );
    PRIVATE_LB_TEST( 20, 4 );
    PRIVATE_LB_TEST( 21, 4 );
    PRIVATE_LB_TEST( 22, 4 );
    PRIVATE_LB_TEST( 23, 4 );
    PRIVATE_LB_TEST( 24, 4 );
    PRIVATE_LB_TEST( 25, 4 );
    PRIVATE_LB_TEST( 26, 4 );
    PRIVATE_LB_TEST( 27, 4 );
    PRIVATE_LB_TEST( 28, 4 );
    PRIVATE_LB_TEST( 29, 4 );
    PRIVATE_LB_TEST( 30, 4 );
    PRIVATE_LB_TEST( 31, 4 );
    PRIVATE_LB_TEST( 32, 5 );
    PRIVATE_LB_TEST( 33, 5 );
    PRIVATE_LB_TEST( 34, 5 );
    PRIVATE_LB_TEST( 35, 5 );
    PRIVATE_LB_TEST( 36, 5 );
    PRIVATE_LB_TEST( 37, 5 );
    PRIVATE_LB_TEST( 38, 5 );
    PRIVATE_LB_TEST( 39, 5 );
    PRIVATE_LB_TEST( 40, 5 );
    PRIVATE_LB_TEST( 63, 5 );
    PRIVATE_LB_TEST( 64, 6 );
    PRIVATE_LB_TEST( 65, 6 );
    PRIVATE_LB_TEST( 127, 6 );
    PRIVATE_LB_TEST( 128, 7 );
    PRIVATE_LB_TEST( 129, 7 );
    PRIVATE_LB_TEST( 255, 7 );
    PRIVATE_LB_TEST( 256, 8 );
    PRIVATE_LB_TEST( 257, 8 );
    PRIVATE_LB_TEST( 511, 8 );
    PRIVATE_LB_TEST( 512, 9 );
    PRIVATE_LB_TEST( 513, 9 );
    PRIVATE_LB_TEST( 1023, 9 );
    PRIVATE_LB_TEST( 1024, 10 );
    PRIVATE_LB_TEST( 1025, 10 );
    PRIVATE_LB_TEST( 2047, 10 );
    PRIVATE_LB_TEST( 2048, 11 );
    PRIVATE_LB_TEST( 2049, 11 );
    PRIVATE_LB_TEST( 4095, 11 );
    PRIVATE_LB_TEST( 4096, 12 );
    PRIVATE_LB_TEST( 4097, 12 );
    PRIVATE_LB_TEST( 8191, 12 );
    PRIVATE_LB_TEST( 8192, 13 );
    PRIVATE_LB_TEST( 8193, 13 );
    PRIVATE_LB_TEST( 16383, 13 );
    PRIVATE_LB_TEST( 16384, 14 );
    PRIVATE_LB_TEST( 16385, 14 );
    PRIVATE_LB_TEST( 32767, 14 );
    PRIVATE_LB_TEST( 32768, 15 );
    PRIVATE_LB_TEST( 32769, 15 );
    PRIVATE_LB_TEST( 65535, 15 );
    PRIVATE_LB_TEST( 65536, 16 );
    PRIVATE_LB_TEST( 65537, 16 );
    return boost::report_errors();
 }
--- a/test/static_min_max_include_test.cpp
+++ b/test/static_min_max_include_test.cpp
@ -0,0 +1,14 @@
 //  Copyright John Maddock 2009.  
 //  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)
 #include <boost/integer/static_min_max.hpp> // must be the only #include!
 int main()
 {
   boost::static_min_max_signed_type m = boost::static_signed_min<2, 3>::value + boost::static_signed_max<2, 3>::value;
   (void)m;
   boost::static_min_max_unsigned_type u = boost::static_unsigned_min<2, 3>::value + boost::static_unsigned_max<2, 3>::value;
   (void)u;
 }
--- a/test/static_min_max_test.cpp
+++ b/test/static_min_max_test.cpp
@ -0,0 +1,92 @@
 //  Boost static_min_max.hpp test program  -----------------------------------//
 //  (C) Copyright Daryle Walker 2001.
 //  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 for most recent version including documentation.
 //  Revision History
 //  23 Sep 2001  Initial version (Daryle Walker)
 #include <boost/detail/lightweight_test.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.
 #include <iostream>  // for std::cout (std::endl indirectly)
 // Main testing function
 int
 main
 (
    int         ,   // "argc" is unused
    char *      []  // "argv" is unused
 )
 {    
    using std::cout;
    using std::endl;
    using boost::static_signed_min;
    using boost::static_signed_max;
    using boost::static_unsigned_min;
    using boost::static_unsigned_max;
    // Two positives
    cout << "Doing tests with two positive values." << endl;
    BOOST_TEST( (static_signed_min< 9, 14>::value) ==  9 );
    BOOST_TEST( (static_signed_max< 9, 14>::value) == 14 );
    BOOST_TEST( (static_signed_min<14,  9>::value) ==  9 );
    BOOST_TEST( (static_signed_max<14,  9>::value) == 14 );
    BOOST_TEST( (static_unsigned_min< 9, 14>::value) ==  9 );
    BOOST_TEST( (static_unsigned_max< 9, 14>::value) == 14 );
    BOOST_TEST( (static_unsigned_min<14,  9>::value) ==  9 );
    BOOST_TEST( (static_unsigned_max<14,  9>::value) == 14 );
    // Two negatives
    cout << "Doing tests with two negative values." << endl;
    BOOST_TEST( (static_signed_min<  -8, -101>::value) == -101 );
    BOOST_TEST( (static_signed_max<  -8, -101>::value) ==   -8 );
    BOOST_TEST( (static_signed_min<-101,   -8>::value) == -101 );
    BOOST_TEST( (static_signed_max<-101,   -8>::value) ==   -8 );
    // With zero
    cout << "Doing tests with zero and a positive or negative value." << endl;
    BOOST_TEST( (static_signed_min< 0, 14>::value) ==  0 );
    BOOST_TEST( (static_signed_max< 0, 14>::value) == 14 );
    BOOST_TEST( (static_signed_min<14,  0>::value) ==  0 );
    BOOST_TEST( (static_signed_max<14,  0>::value) == 14 );
    BOOST_TEST( (static_unsigned_min< 0, 14>::value) ==  0 );
    BOOST_TEST( (static_unsigned_max< 0, 14>::value) == 14 );
    BOOST_TEST( (static_unsigned_min<14,  0>::value) ==  0 );
    BOOST_TEST( (static_unsigned_max<14,  0>::value) == 14 );
    BOOST_TEST( (static_signed_min<   0, -101>::value) == -101 );
    BOOST_TEST( (static_signed_max<   0, -101>::value) ==    0 );
    BOOST_TEST( (static_signed_min<-101,    0>::value) == -101 );
    BOOST_TEST( (static_signed_max<-101,    0>::value) ==    0 );
    // With identical
    cout << "Doing tests with two identical values." << endl;
    BOOST_TEST( (static_signed_min<0, 0>::value) == 0 );
    BOOST_TEST( (static_signed_max<0, 0>::value) == 0 );
    BOOST_TEST( (static_unsigned_min<0, 0>::value) == 0 );
    BOOST_TEST( (static_unsigned_max<0, 0>::value) == 0 );
    BOOST_TEST( (static_signed_min<14, 14>::value) == 14 );
    BOOST_TEST( (static_signed_max<14, 14>::value) == 14 );
    BOOST_TEST( (static_unsigned_min<14, 14>::value) == 14 );
    BOOST_TEST( (static_unsigned_max<14, 14>::value) == 14 );
    BOOST_TEST( (static_signed_min< -101, -101>::value) == -101 );
    BOOST_TEST( (static_signed_max< -101, -101>::value) == -101 );
    return boost::report_errors();
 }
Author	SHA1	Message	Date
Beman Dawes	28e720315e	Branch for 2nd try at V2 removal [SVN r77497]	2012-03-23 12:04:44 +00:00
John Maddock	1898e66238	Apply patch from Vincent Botet Escriba: fix check for size > long long. [SVN r77109]	2012-02-24 16:57:13 +00:00
John Maddock	cc73477d13	Fix typo. Refs #6003. [SVN r76137]	2011-12-24 17:29:03 +00:00
Steven Watanabe	8457bd01b1	Fix integer_traits<long long> when no macro from limits.h is available. [SVN r68802]	2011-02-12 15:06:21 +00:00
John Maddock	707faa1086	Remove old dead code. [SVN r68097]	2011-01-13 13:43:08 +00:00
John Maddock	7bd48eb3f3	Change logic so that int32_t etc is an int rather than a long where possible. [SVN r65299]	2010-09-05 16:27:09 +00:00
John Maddock	7c62277986	Add VMS support. Fixes #4474. [SVN r64750]	2010-08-12 12:36:42 +00:00
Daniel James	8368cd0a55	Rebuild integer docs. [SVN r63765]	2010-07-08 20:50:29 +00:00
Daniel James	794fdf9bad	Update various libraries' documentation build. Mostly to use the images and css files under doc/src instead of doc/html, usually be deleting the settings in order to use the defaults. Also add 'boost.root' to some builds in order to fix links which rely on it. [SVN r63146]	2010-06-20 18:00:48 +00:00
Steven Watanabe	cd98c4a257	Add a 64 bit specialization of low_bits_mask_t. Fixes #4332 [SVN r62756]	2010-06-10 19:49:34 +00:00
Daniel James	84c8a52085	Rebuild the integer documentation. [SVN r61058]	2010-04-05 07:27:25 +00:00
Daniel James	8a1d11f369	Fix link to integer header. [SVN r59676]	2010-02-14 13:09:24 +00:00
John Maddock	a5356bb254	Change integer code to still work when BOOST_HAS_MS_INT64 is defined but BOOST_HAS_LONG_LONG is not. Update VC++ config to define BOOST_HAS_LONG_LONG for MSVC-8 in ANSI mode. Fixes #3657. [SVN r59468]	2010-02-04 11:15:54 +00:00
John Maddock	2f13159023	Change code to check individually for the INT#_C macros before defining them - this correctly handles cases where they are partially defined by other other headers (for example ICU). Also declare this a gcc system header - seems to be the only way to really suppress the warnings - fixes #3889. [SVN r59430]	2010-02-02 18:35:33 +00:00
John Maddock	6293af825a	Commit alternative warning suppression code. [SVN r59264]	2010-01-25 10:55:50 +00:00
Daniel James	896f2a7654	Disable warnings when defining INT#_C macros for gcc. [SVN r58948]	2010-01-12 18:51:40 +00:00
John Maddock	e5c64669e2	Update docs to match code. [SVN r58293]	2009-12-11 17:56:01 +00:00
John Maddock	14e17dd9f6	Update cstdint.hpp to always define the INT#_C macros. Try again with Codegear workaround. [SVN r58292]	2009-12-11 17:46:10 +00:00
John Maddock	86519e7bcf	Extend codegear/borland fix. [SVN r58291]	2009-12-11 15:59:42 +00:00
John Maddock	e5267abf6e	Tentative Borland/Codegear patch. [SVN r58113]	2009-12-03 12:14:15 +00:00
John Maddock	92a617bbe9	Get the tests warning free again with GCC. Finally get everything working with the Borland compiler. Fix a few typos: use of long rather than unsigned long, use of long long rather than long_long_type etc. [SVN r58056]	2009-11-30 13:50:05 +00:00
John Maddock	ad5d5b0e1f	Up template instantiation depth for sun compiler. [SVN r58033]	2009-11-29 16:23:04 +00:00
John Maddock	3af7c55ad9	Make code respect BOOST_NO_INTEGRAL_INT64_T. [SVN r58031]	2009-11-29 16:02:45 +00:00
John Maddock	1797528e35	Change long long to boost::long_long_type etc. [SVN r58029]	2009-11-29 13:59:18 +00:00
John Maddock	05c1f88324	Fix issues in docs. [SVN r58008]	2009-11-28 17:08:31 +00:00
John Maddock	6a497ee263	Regenerate with new stylesheets. [SVN r57968]	2009-11-27 11:13:02 +00:00
John Maddock	98b57c1f3b	Get the tests warning free with gcc, and add conceptual-header-inclusion tests. [SVN r57948]	2009-11-26 18:06:10 +00:00
John Maddock	154b9ce992	Fix some typos. [SVN r57946]	2009-11-26 15:43:32 +00:00
John Maddock	fad95e3d1f	Oops, tests should return the error code is any. [SVN r57943]	2009-11-26 13:35:03 +00:00
John Maddock	b83327861c	Changed to use the lightweight test framework - we can now test with a much wider range of compilers. [SVN r57942]	2009-11-26 12:59:39 +00:00
John Maddock	ac155d3843	Added support for exact width integer type to int_t and uint_t Updated docs to match. Fixes #1225. [SVN r57941]	2009-11-26 11:08:27 +00:00
John Maddock	ca84baa55d	Update Boost.Integer meta-programming classes to work with intmax_t where possible - ie to be 64-bit clean. Added quickbook based docs - updated as necessary. Removed old html docs. [SVN r57926]	2009-11-25 12:38:09 +00:00
Hartmut Kaiser	db267e22f8	Integer: fixed search&replace gone mad [SVN r57908]	2009-11-24 21:24:20 +00:00
John Maddock	cf359129a3	Bring docs into line with code. [SVN r57885]	2009-11-24 10:14:43 +00:00
John Maddock	09ee5872ba	Tidied up namespace usage, fixes #2134 . [SVN r57884]	2009-11-24 10:12:29 +00:00
John Maddock	0248ecb71b	Add history/revision log. [SVN r57883]	2009-11-24 10:07:45 +00:00
John Maddock	ddb6a13f29	Add support for long long throughout. Fixes #653. [SVN r57873]	2009-11-23 18:51:33 +00:00
John Maddock	e07b49c955	remove reference to dead test (no longer relevant) [SVN r57867]	2009-11-23 16:45:21 +00:00
John Maddock	44c3831e05	Fix Jamfile and Boost.Test usage. [SVN r57866]	2009-11-23 16:39:45 +00:00
John Maddock	4c23c47ebe	Add support for MS style __int64 when long long is not available. Fixes #3084. [SVN r57863]	2009-11-23 13:23:15 +00:00
John Maddock	285048504c	Suppress and/or fix warnings - in particular avoid undefined behaviour in the test cases! [SVN r57859]	2009-11-23 10:43:00 +00:00
John Maddock	8cab32a0dd	Fix for Comeau compiler - does not define __GLIBC_HAVE_LONG_LONG which in turn causes GLIBC's stdint.h to misbehave. Fixes #3548. [SVN r57858]	2009-11-23 09:51:23 +00:00
John Maddock	9ff5c9d3b6	Fixes #3180 . [SVN r57845]	2009-11-22 17:12:57 +00:00
John Maddock	dd1194afa4	Fix preprocessor logic for long long support. Fixes #3657. Fixes #3568. [SVN r57843]	2009-11-22 16:38:05 +00:00
John Maddock	eecbd5276f	Reverted Integer back to Release branch state - as per devel-list discussions. [SVN r57580]	2009-11-11 18:57:24 +00:00
John Maddock	fd0a8f8c2c	Suppress gcc warnings: for bug report #1451 . [SVN r57170]	2009-10-27 09:58:40 +00:00
Troy D. Straszheim	f9561fec20	rm cmake from trunk. I'm not entirely sure this is necessary to satisfy the inspect script, but I'm not taking any chances, and it is easy to put back [SVN r56942]	2009-10-17 02:07:38 +00:00
Troy D. Straszheim	9fd48f6a56	Copyrights on CMakeLists.txt to keep them from clogging up the inspect reports. This is essentially the same commit as r55095 on the release branch. [SVN r55159]	2009-07-26 00:49:56 +00:00
Daniel James	edd638ec91	Use BOOST_STATIC_CONSTANT in static_log2, as g++ 4.0 has problems with enum. [SVN r54811]	2009-07-08 21:27:05 +00:00
John Maddock	3706ee7bd9	Fixes #2654 . [SVN r50572]	2009-01-14 10:17:25 +00:00
Daryle Walker	ec8ede3378	Changed control of extra messages to be determined solely by the Boost.Test messaging controls [SVN r50009]	2008-11-29 07:45:02 +00:00
Michael A. Jackson	a8f7c90aff	Updating dependency information for modularized libraries. [SVN r49628]	2008-11-07 17:05:27 +00:00
Michael A. Jackson	768023af1a	Updating CMake files to latest trunk. Added dependency information for regression tests and a few new macros for internal use. [SVN r49627]	2008-11-07 17:02:56 +00:00
Michael A. Jackson	c7e9da6551	Continuing merge of CMake build system files into trunk with the encouragement of Doug Gregor [SVN r49510]	2008-11-01 13:15:41 +00:00
Daryle Walker	2d259a4f3e	Added MPL-compatible variants of the integer-mask class templates (and finally make the lowest-bit-group metafunctions work for zero-length bit-groups) [SVN r47869]	2008-07-29 19:33:20 +00:00
Daryle Walker	2fd0675a21	Hopefully made compile-time constants suitable for more compilers [SVN r47852]	2008-07-28 14:41:00 +00:00
Daryle Walker	f041dc0f0a	Added extended-integer support [SVN r47842]	2008-07-27 17:08:51 +00:00
Daryle Walker	188cef05a9	Changed the Integer-mask test to use the unit-test system [SVN r47841]	2008-07-27 16:34:38 +00:00
Daryle Walker	2ae867bcf8	Corrected link to corresponding test files [SVN r47838]	2008-07-27 09:00:54 +00:00
Daryle Walker	2fcbc31b77	Tightened up code; number of bit-counts sampled is now comprehensive instead of representative (with a preprocessor switch for the old behavior since the new behavior greatly increases compile times) [SVN r47801]	2008-07-25 12:39:06 +00:00
Daryle Walker	4af7660410	Encapsulated the mutually exclusive 'long long' and '__int64' type families into a single interface [SVN r47754]	2008-07-24 11:43:02 +00:00
Daryle Walker	2b7ed6ebf7	Resolved namespace conflict from unadorned call, which fixes #2134 [SVN r47742]	2008-07-23 22:40:20 +00:00
Daryle Walker	203705fea6	Moved preprocessor selection from within macro-function calls to surrounding whole macro calls (some compilers suspend preprocessor directives within a macro call) [SVN r47696]	2008-07-23 06:55:23 +00:00
Daryle Walker	ed80575830	Added MPL-compatible variants of the minimum-size and value-based integer templates, which fixes #1224 [SVN r47470]	2008-07-16 09:55:31 +00:00
Daryle Walker	f27ad7b337	Added MPL-compatible variant of the processor-optimized integer template [SVN r47452]	2008-07-15 18:56:59 +00:00
Daryle Walker	55e1796c7a	Added exact-integer templates, which fixes #1225 (and completes #653 ) [SVN r47434]	2008-07-15 09:59:19 +00:00
Daryle Walker	053be71261	Added extended-integer support, which fixes #653 (the main part; the secondary part is split off as #1225 ) [SVN r47414]	2008-07-14 06:28:54 +00:00
Daryle Walker	10e5587b9e	Improved/added testing for the processor-optimized integer template [SVN r47413]	2008-07-14 04:25:31 +00:00
Daryle Walker	2f91e69629	Re-did implementation [SVN r47408]	2008-07-13 23:30:18 +00:00
Daryle Walker	422ef1ebe6	Replaced comprehensive macros with focused templates [SVN r47404]	2008-07-13 21:08:16 +00:00
Daryle Walker	edfaeb6c0e	Changed the Integer-selection test to use the unit-test system [SVN r47200]	2008-07-07 23:13:43 +00:00
Daryle Walker	3c7910fad3	Added entries for the forgotten tests [SVN r47123]	2008-07-06 00:58:34 +00:00
Rene Rivera	600801670e	Move integer tests into canonical test subdir structure. [SVN r44384]	2008-04-13 23:00:19 +00:00
Daniel James	4e2c8440b5	Point links to the pages that used to be in 'more' to the site. [SVN r43210]	2008-02-10 15:02:17 +00:00
Daniel James	94ace80618	Link to people pages on the website, as they've been removed from the download. [SVN r43209]	2008-02-10 14:56:22 +00:00
Daniel James	cd6a9565ff	Fix the link to the license. [SVN r43193]	2008-02-09 13:02:45 +00:00
Beman Dawes	0d058f42cc	Add missing copyright and license [SVN r40835]	2007-11-06 13:41:19 +00:00
Daryle Walker	7d8e93a6ac	Fixed comments listed in #766 that didn't match their described code [SVN r39062]	2007-08-29 19:54:14 +00:00
Daryle Walker	a1cc143de7	Added license to a person profile; updated license on Boost.Integer and Boost.IO doc files; changed 'BOOST_TEST' to 'BOOST_CHECK' on Boost.Integer testing *.cpp files [SVN r35844]	2006-11-04 22:58:43 +00:00
John Maddock	cd99f24a87	Changed test to reflect changes made to C99 in the TC. [SVN r35333]	2006-09-26 09:04:05 +00:00
John Maddock	93612e6c0b	QNX does have a wchar.h and WCHAR_MAX/WCHAR_MIN even though there's not much else in it! [SVN r32576]	2006-02-05 10:19:42 +00:00
John Maddock	d9f5b1bbf9	Apparently we forgot to include <limits.h> [SVN r32397]	2006-01-24 17:23:54 +00:00
Douglas Gregor	37d7590f2f	Merged from Version_1_33_1 [SVN r31949]	2005-12-08 03:23:02 +00:00
Rene Rivera	cb9a7792cc	Merge from RC_1_33_0. [SVN r31703]	2005-11-19 19:38:13 +00:00
John Maddock	291bb8c525	Enable support for Dragonfly BSD [SVN r30647]	2005-08-24 15:45:17 +00:00
Beman Dawes	8602a17a10	Replace buggy Cygwin INTMAX_C and UINTMAX_C macros [SVN r29276]	2005-05-30 01:45:13 +00:00
Joaquín M. López Muñoz	29275d71aa	added workaround for duplicate comdat errors in MSVC++ 6.0 [SVN r29186]	2005-05-25 13:43:12 +00:00
Markus Schöpflin	9df9a90217	Make PRIVATE_FIT_TESTS() work correctly on 64-bit machines. [SVN r28779]	2005-05-10 08:40:28 +00:00
Douglas Gregor	65607e3b82	Work around SunPro 5.3 issue [SVN r28715]	2005-05-07 13:16:49 +00:00
Douglas Gregor	39399de102	WCHAR_MIN is not trustworthy on MacOS X [SVN r28714]	2005-05-07 13:14:07 +00:00
Stefan Slapeta	27aae3b3cb	replaced BOOST_TEST [SVN r27054]	2005-02-03 13:48:49 +00:00
John Maddock	21fe6251ab	Fix to ensure that <wchar.h> is included on solaris (thanks to bug report by Caleb Epstein). [SVN r26542]	2004-12-17 11:56:15 +00:00
Markus Schöpflin	07019a8801	Better support for Tru64. [SVN r25689]	2004-10-12 16:42:58 +00:00
Aleksey Gurtovoy	3892592661	c++boost.gif -> boost.png replacement [SVN r25573]	2004-10-05 15:45:52 +00:00
John Maddock	0935f20c69	Added new types boost::long_long_type and boost::ulong_long_type in boost/config.hpp and applied these types in place of "long long" throughout. As a result, almost all of boost now compiles cleanly with -ansi -pedantic with gcc. Changes tested with gcc 3.3, 2.95, VC7.1 and Intel 8. [SVN r24899]	2004-09-04 10:34:49 +00:00
John Maddock	7197caf500	Added Daryle Walker's copyrights as requested. [SVN r24481]	2004-08-15 10:13:49 +00:00
John Maddock	92a46aac83	Removed boost.org copyright assignments, and reverted to orginal author (as based on cvs history). [SVN r24402]	2004-08-11 10:59:33 +00:00
John Maddock	c32a045fa4	Removed Boost.org copyrights and replaced with originating authors copyright instead. [SVN r24372]	2004-08-10 12:53:34 +00:00
Rene Rivera	0c31aa03f0	Don't #error when doing a release build. Just put out an informative message, and pass the test. [SVN r24328]	2004-08-07 06:25:20 +00:00
Douglas Gregor	bfc384a435	License update [SVN r24180]	2004-07-30 04:46:56 +00:00
Douglas Gregor	198530a48d	Converted to Boost Software License, Version 1.0 [SVN r24096]	2004-07-27 03:43:34 +00:00
John Maddock	91f511cab4	Licence update [SVN r24031]	2004-07-25 12:01:00 +00:00
Gennaro Prota	0f84fe35da	fixed typo in comment [SVN r23945]	2004-07-22 09:02:43 +00:00
Gennaro Prota	fa5aba353f	- documented the new typedefs - added a what's new section - reformatted a bit - updated license reference [SVN r23944]	2004-07-22 08:57:45 +00:00
Gennaro Prota	170a352574	new version - more efficient, and with no dependency on numeric_limits<> [SVN r23829]	2004-07-20 09:49:43 +00:00
Eric Niebler	4862574bb1	remove minmax hack from win32.hpp and fix all places that could be affected by the minmax macros [SVN r22394]	2004-02-26 18:27:02 +00:00
John Maddock	f2d22d091f	Patches for cstdint support: cygwin and mingw now use native stdint headers. default header now compiles in -pedantic -ansi mode with gcc. [SVN r21728]	2004-01-14 13:30:49 +00:00
Beman Dawes	1e6ab2dc10	index.htm renamed index.html [SVN r21231]	2003-12-11 23:31:15 +00:00
Beman Dawes	a656e7744f	Change license message to reference Boost Software License [SVN r20038]	2003-09-12 17:09:29 +00:00
John Maddock	46fdbba4b8	Added NetBSD patches from Angus Leeming [SVN r19804]	2003-08-27 10:30:53 +00:00
Douglas Gregor	f2ea03679b	Make sure to define __STDC_CONSTANT_MACROS before we include anything [SVN r19747]	2003-08-23 13:21:30 +00:00
Beman Dawes	890e28ab67	include <boost/limits.hpp> instead of <limits.h>, fixing a date-time issue on Comeau [SVN r18499]	2003-05-22 18:09:32 +00:00
John Maddock	1252426554	Added Cray X1 support [SVN r17022]	2003-01-24 11:57:27 +00:00
John Maddock	19fb03cefe	Added Cray support [SVN r16989]	2003-01-22 12:12:14 +00:00
Beman Dawes	a9b35df2f8	add or update See www.boost.org comments [SVN r16708]	2002-12-27 16:51:53 +00:00
John Maddock	49a8d69fe3	minor fix for integer_traits, changed is_pod.hpp include to is_POD.hpp as a temporary fix [SVN r15996]	2002-10-27 12:16:39 +00:00
John Maddock	9cc587a7f2	Merged changes from RC_1_29_0 branch [SVN r15958]	2002-10-21 11:00:50 +00:00
Beman Dawes	2de1422682	boost/test/minimal.hpp [SVN r15234]	2002-09-09 11:58:24 +00:00
Beman Dawes	344fe9f30a	clear un/signed warnings [SVN r14692]	2002-08-05 11:16:14 +00:00
Beman Dawes	8ad3bbafbc	BOOST_HAS_MS_INT64 rather than specific compilers [SVN r14668]	2002-08-05 00:02:10 +00:00
Beman Dawes	cc1183d347	Check for BOOST_HAS_MS_INT64 instead of specific compilers [SVN r14664]	2002-08-04 01:27:24 +00:00
Dave Abrahams	a9703fa803	Fix link [SVN r14630]	2002-07-27 20:08:51 +00:00
John Maddock	5e26f47535	Fixed test case for VC7.0 [SVN r14627]	2002-07-27 11:47:04 +00:00
Dave Abrahams	57e7ccd494	Fix unversioned VC++ checks [SVN r14436]	2002-07-13 12:26:19 +00:00
Björn Karlsson	c56e4674f8	Update from Daryle [SVN r14187]	2002-06-19 20:11:17 +00:00
John Maddock	41620a14f9	Patched so that the code now compilers with VC6 [SVN r13669]	2002-05-05 11:00:28 +00:00
Beman Dawes	a42ede713e	fix link [SVN r12698]	2002-02-04 18:55:31 +00:00
Douglas Gregor	92de2f44a0	cstdint.hpp: - Handle FreeBSD's <inttypes.h> [SVN r12601]	2002-01-31 12:58:35 +00:00
Douglas Gregor	59779dec2c	integer_traits.hpp: - Handle wchar_t traits on FreeBSD [SVN r12467]	2002-01-23 19:56:07 +00:00
Dave Abrahams	3bb567ad9d	initial checkin [SVN r11972]	2001-12-07 13:19:38 +00:00
Dave Abrahams	c50993d5d4	Added daryle's missing files [SVN r11971]	2001-12-07 12:48:20 +00:00
Dave Abrahams	5477a9641c	initial checkin [SVN r11898]	2001-12-03 23:55:35 +00:00
Dave Abrahams	162c6aefa1	Integrated Daryle Walker's dlw_int.zip changes [SVN r11866]	2001-12-03 03:29:57 +00:00
Jens Maurer	24e6bfbfaa	add definition for integral constants initialized in-class [SVN r11724]	2001-11-18 17:37:21 +00:00
Darin Adler	ccabb522d0	Remove non-ASCII character that crept in. [SVN r11570]	2001-11-04 21:53:21 +00:00
Jens Maurer	0995d0a6fb	only use "long long" if there's a stdlib overload [SVN r11516]	2001-11-01 21:52:08 +00:00
Jens Maurer	5ec8116c34	use BOOST_HAS_LONG_LONG [SVN r11493]	2001-10-31 19:35:59 +00:00
Jens Maurer	4a094c4bcb	fix wchar_t on HP-UX with gcc [SVN r11472]	2001-10-30 20:55:18 +00:00
Beman Dawes	a7d2da8d1c	1.25.0 Final runup [SVN r11315]	2001-10-01 15:54:23 +00:00
Darin Adler	4d2a921dbf	Write out limits as integers, even for char types. [SVN r11301]	2001-09-28 17:38:10 +00:00
Darin Adler	0c758855e4	Since it's obsolete, it should be removed. [SVN r11300]	2001-09-28 17:37:25 +00:00
Darin Adler	3399df597e	Add case for Mac OS X to the WCHAR_MIN/WCHAR_MAX section. [SVN r11242]	2001-09-24 23:45:49 +00:00
Jens Maurer	a066e242b0	always use WCHAR_MIN and WCHAR_MAX if defined [SVN r11232]	2001-09-24 18:43:20 +00:00
Jens Maurer	a635f753a4	port cstdint.hpp to HP-UX [SVN r11175]	2001-09-20 19:25:35 +00:00
Jens Maurer	08f30ea46c	moved check, because different unsigned types may have different representations for -1 (e.g. (unsigned char)-1 and (unsigned int)-1) [SVN r11174]	2001-09-20 19:24:34 +00:00
John Maddock	292eeb5c90	Fixes for broken using declarations [SVN r11164]	2001-09-20 11:44:34 +00:00
John Maddock	8a105dab3f	Fixes for the case that platform has its own stdint.h (less stringent tests) [SVN r11163]	2001-09-20 11:44:05 +00:00
John Maddock	5b0d514aa4	commit of split-config, including any changes required to existing libraries (mainly regex). [SVN r11138]	2001-09-18 11:13:39 +00:00
Jens Maurer	eee6dfa4d9	avoid "long long" with SunCC (Gennadiy E. Rozental) [SVN r11066]	2001-09-07 18:49:12 +00:00
Beman Dawes	3bd242ef49	Fix broken hyperlink [SVN r10896]	2001-08-19 15:08:33 +00:00
Beman Dawes	3db9390efb	Add LL suffix to line 150 for long longs at suggestion of Toon Knapen [SVN r10854]	2001-08-13 17:02:48 +00:00
John Maddock	c6f3dce91a	Fixed VC6+STLport-4.1b6 (changed preprocessor logic) [SVN r10360]	2001-06-20 11:42:44 +00:00
Jens Maurer	3e2b929118	free -> fee [SVN r10248]	2001-05-31 17:22:20 +00:00