This commit was manufactured by cvs2svn to create branch 'SPIRIT_1_6'.

[SVN r23968]
new version - more efficient, and with no dependency on numeric_limits<>
2004-07-23 02:16:28 +00:00 · 2004-07-20 09:49:43 +00:00 · 2004-02-26 18:27:02 +00:00 · 2004-01-14 13:30:49 +00:00 · 2003-12-11 23:31:15 +00:00 · 2003-09-12 17:09:29 +00:00
18 changed files with 181 additions and 2025 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 -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" -->
-</p>
-<p>&nbsp;</p>
-
-</body>
-
-</html>
--- a/cstdint_test.cpp
+++ b/cstdint_test.cpp
@ -1,217 +0,0 @@
-//  boost cstdint.hpp test program  ------------------------------------------//
-
-//  (C) Copyright Beman Dawes 2000. 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
-//   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>
-#define __STDC_CONSTANT_MACROS
-#include <boost/cstdint.hpp>
-
-#ifdef NDEBUG
-#error This test makes no sense with NDEBUG defined
-#endif
-
-#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()
-{
-  assert( int8 == -127 );
-  assert( int_least8 == -127 );
-  assert( int_fast8 == -127 );
-  assert( uint8 == 255u );
-  assert( uint_least8 == 255u );
-  assert( uint_fast8 == 255u );
-  assert( int16 == -32767 );
-  assert( int_least16 == -32767 );
-  assert( int_fast16 == -32767 );
-  assert( uint16 == 65535u );
-  assert( uint_least16 == 65535u );
-  assert( uint_fast16 == 65535u );
-  assert( int32 == -2147483647 );
-  assert( int_least32 == -2147483647 );
-  assert( int_fast32 == -2147483647 );
-  assert( uint32 == 4294967295u );
-  assert( uint_least32 == 4294967295u );
-  assert( 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:
-   assert(sizeof(T1) <= sizeof(T2));
-#else
-   assert(sizeof(T1) == sizeof(T2));
-   assert(t1 == t2);
-#endif
-   if(t1 > 0)
-     assert(t2 > 0);
-   else
-     assert(!(t2 > 0));
-}
-
-
-int main()
-{
-#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
-
-  assert( int8 == -127 );
-  assert( int_least8 == -127 );
-  assert( int_fast8 == -127 );
-  assert( uint8 == 255u );
-  assert( uint_least8 == 255u );
-  assert( uint_fast8 == 255u );
-  assert( int16 == -32767 );
-  assert( int_least16 == -32767 );
-  assert( int_fast16 == -32767 );
-  assert( uint16 == 65535u );
-  assert( uint_least16 == 65535u );
-  assert( uint_fast16 == 65535u );
-  assert( int32 == -2147483647 );
-  assert( int_least32 == -2147483647 );
-  assert( int_fast32 == -2147483647 );
-  assert( uint32 == 4294967295u );
-  assert( uint_least32 == 4294967295u );
-  assert( uint_fast32 == 4294967295u );
-
-#ifndef BOOST_NO_INT64_T
-  assert( int64 == INT64_C(-9223372036854775807) );
-  assert( int_least64 == INT64_C(-9223372036854775807) );
-  assert( int_fast64 == INT64_C(-9223372036854775807) );
-  assert( uint64 == UINT64_C(18446744073709551615) );
-  assert( uint_least64 == UINT64_C(18446744073709551615) );
-  assert( uint_fast64 == UINT64_C(18446744073709551615) );
-  assert( intmax == INT64_C(-9223372036854775807) );
-  assert( uintmax == UINT64_C(18446744073709551615) );
-#else
-  assert( intmax == -2147483647 );
-  assert( uintmax == 4294967295u );
-#endif
-
-
-  std::cout << "OK\n";
-  return 0;
-}
-
-
--- a/doc/integer_mask.html
+++ b/doc/integer_mask.html
@ -1,211 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<html>
-<head>
-<title>Integer Bit Mask Templates</title>
-</head>
-
-<body bgcolor="white" text="black" link="blue" vlink="purple" alink="red">
-<h1><img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
-align="middle" width="277" height="86">Integer Bit Mask Templates</h1>
-
-<p>The class templates in <cite><a href="../../../boost/integer/integer_mask.hpp">&lt;boost/integer/integer_mask.hpp&gt;</a></cite> provide bit masks for a certain bit position or a contiguous-bit pack of a certain size.  The types of the masking constants come from the <a href="../integer.htm">integer type selection templates</a> header.</p>
-
-<h2><a name="contents">Contents</a></h2>
-
-<ul>
-	<li><a href="#contents">Contents</a></li>
-	<li><a href="#synopsis">Synopsis</a></li>
-	<li><a href="#single">Single Bit-Mask Class Template</a></li>
-	<li><a href="#group">Group Bit-Mask Class Template</a></li>
-	<li><a href="#example">Example</a></li>
-	<li><a href="#demo">Demonstration Program</a></li>
-	<li><a href="#rationale">Rationale</a></li>
-	<li><a href="#credits">Credits</a></li>
-</ul>
-
-<h2><a name="synopsis">Synopsis</a></h2>
-
-<blockquote><pre>
-#include &lt;cstddef&gt;  <i>// for std::size_t</i>
-
-namespace boost
-{
-
-template &lt; std::size_t Bit &gt;
-struct high_bit_mask_t
-{
-    typedef <em>implementation_supplied</em>  least;
-    typedef <em>implementation_supplied</em>   fast;
-
-    static const least  high_bit = <em>implementation_defined</em>;
-    static const fast   high_bit_fast = <em>implementation_defined</em>;
-
-    static const std::size_t  bit_position = Bit;
-
-};
-
-template &lt; std::size_t Bits &gt;
-struct low_bits_mask_t
-{
-    typedef <em>implementation_supplied</em>  least;
-    typedef <em>implementation_supplied</em>   fast;
-
-    static const least  sig_bits = <em>implementation_defined</em>;
-    static const fast   sig_bits_fast = <em>implementation_defined</em>;
-
-    static const std::size_t  bit_count = Bits;
-
-};
-
-// Specializations for low_bits_mask_t exist for certain bit counts.
-
-}  // namespace boost
-</pre></blockquote>
-
-<h2><a name="single">Single Bit-Mask Class Template</a></h2>
-
-<p>The <code>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><code>Bit</code></sup>, where
-<code>Bit</code> is the template parameter.  The bit position must be a
-nonnegative number from zero to <i>Max</i>, where <dfn>Max</dfn> 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>high_bit_mask_t</code>.</p>
-
-<table border="1" cellpadding="5">
-	<caption>Members of the <code>boost::high_bit_mask_t</code> Class
-		Template</caption>
-	<tr>
-		<th>Member</th>
-		<th>Meaning</th>
-	</tr>
-	<tr>
-		<td><code>least</code></td>
-		<td>The smallest unsigned built-in type that supports the given
-			bit position.</td>
-	</tr>
-	<tr>
-		<td><code>fast</code></td>
-		<td>The quick-to-manipulate analog of <code>least</code>.</td>
-	</tr>
-	<tr>
-		<td><code>high_bit</code></td>
-		<td>A <code>least</code> constant of the desired bit-masking
-			value.</td>
-	</tr>
-	<tr>
-		<td><code>high_bit_fast</code></td>
-		<td>A <code>fast</code> analog of <code>high_bit</code>.</td>
-	</tr>
-	<tr>
-		<td><code>bit_position</code></td>
-		<td>The value of the template parameter, in case its needed from
-			a renamed instantiation of the class template.</td>
-	</tr>
-</table>
-
-<h2><a name="group">Group Bit-Mask Class Template</a></h2>
-
-<p>The <code>boost::low_bits_mask_t</code> class template provides
-constants for bit masks representing the lowest bits of a certain
-amount.  The masks are equivalent to the value
-(2<sup><code>Bits</code></sup> - 1), where <code>Bits</code> is the
-template parameter.  The bit amount must be a nonnegative number from
-zero to <i>Max</i>, where <dfn>Max</dfn> is the number of bits supported
-by the largest unsigned built-in integral type.  The following table
-describes the members of an instantiation of
-<code>low_bits_mask_t</code>.</p>
-
-<table border="1" cellpadding="5">
-	<caption>Members of the <code>boost::low_bits_mask_t</code> Class
-		Template</caption>
-	<tr>
-		<th>Member</th>
-		<th>Meaning</th>
-	</tr>
-	<tr>
-		<td><code>least</code></td>
-		<td>The smallest unsigned built-in type that supports the given
-			bit count.</td>
-	</tr>
-	<tr>
-		<td><code>fast</code></td>
-		<td>The quick-to-manipulate analog of <code>least</code>.</td>
-	</tr>
-	<tr>
-		<td><code>sig_bits</code></td>
-		<td>A <code>least</code> constant of the desired bit-masking
-			value.</td>
-	</tr>
-	<tr>
-		<td><code>sig_bits_fast</code></td>
-		<td>A <code>fast</code> analog of <code>sig_bits</code>.</td>
-	</tr>
-	<tr>
-		<td><code>bit_count</code></td>
-		<td>The value of the template parameter, in case its needed from
-			a renamed instantiation of the class template.</td>
-	</tr>
-</table>
-
-<p><strong>Implementation Note</strong><br>
-When <code>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>low_bits_mask_t</code> at
-those bit counts.</p>
-
-<h2><a name="example">Example</a></h2>
-
-<blockquote><pre>
-#include &lt;boost/integer/integer_mask.hpp&gt;
-
-//...
-
-int main()
-{
-    typedef boost::high_bit_mask_t&lt;29&gt;  mask1_type;
-    typedef boost::low_bits_mask_t&lt;15&gt;  mask2_type;
-
-    mask1_type::least  my_var1;
-    mask2_type::fast   my_var2;
-    //...
-
-    my_var1 |= mask1_type::high_bit;
-    my_var2 &amp;= mask2_type::sig_bits_fast;
-
-    //...
-}
-</pre></blockquote>
-
-<h2><a name="demo">Demonstration Program</a></h2>
-
-<p>The program <a href="../test/integer_mask_test.cpp">integer_mask_test.cpp</a>
-is a simplistic demonstration of the results from instantiating various
-examples of the bit mask class templates.</p>
-
-<h2><a name="rationale">Rationale</a></h2>
-
-<p>The class templates in this header are an extension of the <a
-href="../integer.htm">integer type selection class templates</a>.  The new
-class templates provide the same sized types, but also convienent masks
-to use when extracting the highest or all the significant bits when the
-containing built-in type contains more bits.  This prevents
-contaimination of values by the higher, unused bits.</p>
-
-<h2><a name="credits">Credits</a></h2>
-
-<p>The author of the Boost bit mask class templates is <a
-href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>
-
-<hr>
-
-<p>Revised September 23, 2001</p>
-
-<p>&copy; Copyright Daryle Walker 2001.  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>
-</body>
-</html>
--- a/doc/static_log2.html
+++ b/doc/static_log2.html
@ -1,123 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<html>
-<head>
-<title>Binary Logarithm Template</title>
-</head>
-
-<body bgcolor="white" text="black">
-<h1><img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
-align="middle" width="277" height="86">Binary Logarithm Template</h1>
-
-<p>The class template in <cite><a href="../../../boost/integer/static_log2.hpp">&lt;boost/integer/static_log2.hpp&gt;</a></cite> determines the position of the highest bit in a given value.  This facility is useful for solving generic programming problems.</p>
-
-<h2><a name="contents">Contents</a></h2>
-
-<ul>
-	<li><a href="#contents">Contents</a></li>
-	<li><a href="#synopsis">Synopsis</a></li>
-	<li><a href="#usage">Usage</a></li>
-	<li><a href="#example">Example</a></li>
-	<li><a href="#demo">Demonstration Program</a></li>
-	<li><a href="#rationale">Rationale</a></li>
-	<li><a href="#credits">Credits</a></li>
-</ul>
-
-<h2><a name="synopsis">Synopsis</a></h2>
-
-<blockquote><pre>
-namespace boost
-{
-
-template &lt; unsigned long Value &gt;
-struct static_log2
-{
-    static const int  value = <em>implementation_defined</em>;
-};
-
-template &lt; &gt;
-struct static_log2&lt; 0ul &gt;
-{
-    // The logarithm of zero is undefined.
-};
-
-}  // namespace boost
-</pre></blockquote>
-
-<h2><a name="usage">Usage</a></h2>
-
-<p>The <code>boost::static_log2</code> class template takes one template
-parameter, a value of type <code>unsigned long</code>.  The template
-only defines one member, <code>value</code>, that returns the truncated
-base-two logarithm of the template parameter.</p>
-
-<p>Since the logarithm of zero, for any base, is undefined, there is a
-specialization of <code>static_log2</code> for a template parameter
-of zero.  This specialization has no members, so an attempt to use
-the base-two logarithm of zero results in a compile-time error.</p>
-
-<h2><a name="example">Example</a></h2>
-
-<blockquote><pre>
-#include &lt;boost/integer/static_log2.hpp&gt;
-
-template &lt; unsigned long Value &gt;
-bool is_it_what()
-{
-    typedef boost::static_log2&lt;Value&gt;  lb_type;
-
-    int  temp = lb_type::value;
-    //...
-
-    return (temp % 2) != 0;
-}
-
-//...
-
-int main()
-{
-    bool  temp = is_it_what&lt;2000&gt;();
-    //...
-
-    #if 0
-    temp = is_it_what&lt;0&gt;();  // would give an error
-    #endif
-    //...
-
-    temp = is_it_what&lt;24&gt;();
-    //...
-}
-</pre></blockquote>
-
-<h2><a name="demo">Demonstration Program</a></h2>
-
-<p>The program <a href="../test/static_log2_test.cpp">static_log2_test.cpp</a>
-is a simplistic demonstration of the results from instantiating various
-examples of the binary logarithm class template.</p>
-
-<h2><a name="rationale">Rationale</a></h2>
-
-<p>The base-two (binary) logarithm, abbreviated <dfn>lb</dfn>, function
-is occasionally used to give order-estimates of computer algorithms. 
-The truncated logarithm can be considered the highest power-of-two in a
-value, which corresponds to the value's highest set bit (for binary
-integers).  Sometimes the highest-bit position could be used in generic
-programming, which requires the position to be statically (<i>i.e.</i>
-at compile-time) available.</p>
-
-<h2><a name="credits">Credits</a></h2>
-
-<p>The author of the Boost binary logarithm class template is <a
-href="../../../people/daryle_walker.html">Daryle Walker</a>.  Giovanni Bajo
-added support for compilers without partial template specialization.</p>
-
-<hr>
-
-<p>Revised May 14, 2002</p>
-
-<p>&copy; Copyright Daryle Walker 2001.  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>
-</body>
-</html>
--- a/doc/static_min_max.html
+++ b/doc/static_min_max.html
@ -1,121 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<html>
-<head>
-<title>Compile-Time Extrema Templates</title>
-</head>
-
-<body bgcolor="white" text="black" link="blue" alink="red" vlink="purple">
-<h1><img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
-align="middle" width="277" height="86">Compile-Time Extrema
-Templates</h1>
-
-<p>The class templates in <cite><a
-href="../../../boost/integer/static_min_max.hpp">&lt;boost/integer/static_min_max.hpp&gt;</a></cite>
-provide a compile-time evaluation of the minimum or maximum of
-two integers.  These facilities are useful for generic programming problems.</p>
-
-<h2><a name="contents">Contents</a></h2>
-
-<ul>
-	<li><a href="#contents">Contents</a></li>
-	<li><a href="#synopsis">Synopsis</a></li>
-	<li><a href="#usage">Usage</a></li>
-	<li><a href="#example">Example</a></li>
-	<li><a href="#demo">Demonstration Program</a></li>
-	<li><a href="#rationale">Rationale</a></li>
-	<li><a href="#credits">Credits</a></li>
-</ul>
-
-<h2><a name="synopsis">Synopsis</a></h2>
-
-<blockquote><pre>
-namespace boost
-{
-
-template &lt; long Value1, long Value2 &gt;
-    struct static_signed_min;
-
-template &lt; long Value1, long Value2 &gt;
-    struct static_signed_max;
-
-template &lt; unsigned long Value1, unsigned long Value2 &gt;
-    struct static_unsigned_min;
-
-template &lt; unsigned long Value1, unsigned long Value2 &gt;
-    struct static_unsigned_max;
-
-}
-</pre></blockquote>
-
-<h2><a name="usage">Usage</a></h2>
-
-<p>The four class templates provide the combinations for finding the
-minimum or maximum of two signed or <code>unsigned</code>
-(<code>long</code>) parameters, <var>Value1</var> and <var>Value2</var>,
-at compile-time.  Each template has a single static data member,
-<code>value</code>, which is set to the respective minimum or maximum
-of the template's parameters.</p>
-
-<h2><a name="example">Example</a></h2>
-
-<blockquote><pre>
-#include &lt;boost/integer/static_min_max.hpp&gt;
-
-template &lt; unsigned long AddendSize1, unsigned long AddendSize2 &gt;
-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&lt;AddendSize1, AddendSize2&gt;::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 &amp;a1, addend2_type const &amp;a2, sum_type &amp;s ) const;
-};
-
-//...
-
-int main()
-{
-    int const   a1[] = { 0, 4, 3 };  // 340
-    int const   a2[] = { 9, 8 };     //  89
-    int         s[ 4 ];
-    adder&lt;3,2&gt;  obj;
-
-    obj( a1, a2, s );  // 's' should be 429 or { 9, 2, 4, 0 }
-    //...
-}
-</pre></blockquote>
-
-<h2><a name="demo">Demonstration Program</a></h2>
-
-<p>The program <a
-href="../test/static_min_max_test.cpp">static_min_max_test.cpp</a> is a
-simplistic demonstration of various comparisons using the compile-time
-extrema class templates.</p>
-
-<h2><a name="rationale">Rationale</a></h2>
-
-<p>Sometimes the minimum or maximum of several values needs to be found
-for later compile-time processing, <i>e.g.</i> for a bound for another
-class template.</p>
-
-<h2><a name="credits">Credits</a></h2>
-
-<p>The author of the Boost compile-time extrema class templates is <a
-href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>
-
-<hr>
-
-<p>Revised October 12, 2001</p>
-
-<p>&copy; Copyright Daryle Walker 2001.  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>
-</body>
-</html>
--- a/include/boost/cstdint.hpp
+++ b/include/boost/cstdint.hpp
@ -6,7 +6,7 @@
 //  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
 //   31 Oct 01  use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.)
@ -35,7 +35,7 @@
      // this is triggered with GCC, because it defines __cplusplus < 199707L
 #     define BOOST_NO_INT64_T
 #   endif 
-# elif defined(__FreeBSD__)
+# elif defined(__FreeBSD__) || defined(__IBMCPP__)
 #   include <inttypes.h>
 # else
 #   include <stdint.h>
@ -131,7 +131,7 @@ namespace boost {

 #else  // BOOST_HAS_STDINT_H

-# include <limits.h> // implementation artifact; not part of interface
+# include <boost/limits.hpp> // implementation artifact; not part of interface


 namespace boost
@ -161,12 +161,29 @@ namespace boost
 //  16-bit types  -----------------------------------------------------------//

 # if USHRT_MAX == 0xffff
+#  if defined(__crayx1)
+     // The Cray X1 has a 16-bit short, however it is not recommend
+     // for use in performance critical code.
+     typedef short           int16_t;
+     typedef short           int_least16_t;
+     typedef int             int_fast16_t;
+     typedef unsigned short  uint16_t;
+     typedef unsigned short  uint_least16_t;
+     typedef unsigned int    uint_fast16_t;
+#  else
     typedef short           int16_t;
     typedef short           int_least16_t;
     typedef short           int_fast16_t;
     typedef unsigned short  uint16_t;
     typedef unsigned short  uint_least16_t;
     typedef unsigned short  uint_fast16_t;
+#  endif
+# elif (USHRT_MAX == 0xffffffff) && defined(CRAY)
+     // no 16-bit types on Cray:
+     typedef short           int_least16_t;
+     typedef short           int_fast16_t;
+     typedef unsigned short  uint_least16_t;
+     typedef unsigned short  uint_fast16_t;
 # else
 #    error defaults not correct; you must hand modify boost/cstdint.hpp
 # endif
@ -228,6 +245,15 @@ namespace boost
 #    else
 #       error defaults not correct; you must hand modify boost/cstdint.hpp
 #    endif
+# elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG)
+     __extension__ typedef long long            intmax_t;
+     __extension__ typedef unsigned long long   uintmax_t;
+     __extension__ typedef long long            int64_t;
+     __extension__ typedef long long            int_least64_t;
+     __extension__ typedef long long            int_fast64_t;
+     __extension__ typedef unsigned long long   uint64_t;
+     __extension__ typedef unsigned long long   uint_least64_t;
+     __extension__ typedef unsigned long long   uint_fast64_t;
 # elif defined(BOOST_HAS_MS_INT64)
     //
     // we have Borland/Intel/Microsoft __int64:
@ -374,3 +400,5 @@ BOOST_HAS_STDINT_H is defined (John Maddock).
 #endif // __STDC_CONSTANT_MACROS_DEFINED etc.


+
+
--- a/include/boost/integer.hpp
+++ b/include/boost/integer.hpp
@ -1,12 +1,9 @@
 //  boost integer.hpp header file  -------------------------------------------//

-//  (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.
+//  Copyright Beman Dawes 1999.
+//  See accompanying license for terms and conditions of use.

-//  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)
--- a/include/boost/integer/static_log2.hpp
+++ b/include/boost/integer/static_log2.hpp
@ -1,141 +1,132 @@
-//  Boost integer/static_log2.hpp header file  -------------------------------//
+// -------------- 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.
+// ------------------------------------------------------------------------- //

-//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears 
-//  in all copies.  This software is provided "as is" without express or
-//  implied warranty, and with no claim as to its suitability for any purpose. 
-
-//  See http://www.boost.org for updates, documentation, and revision history. 

 #ifndef BOOST_INTEGER_STATIC_LOG2_HPP
 #define BOOST_INTEGER_STATIC_LOG2_HPP

-#include <boost/integer_fwd.hpp>  // self include
+#include "boost/config.hpp" // for BOOST_STATIC_CONSTANT

-#include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT, etc.
-#include <boost/limits.hpp>  // for std::numeric_limits
+namespace boost {

-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/pending/ct_if.hpp>  // for boost::ct_if<>
-#endif
+ 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 unsigned long argument_type;
+     typedef          int  result_type;


-namespace boost
-{
+     template <result_type n>
+     struct choose_initial_n {
+
+         enum { c = (argument_type(1) << n << n) != 0 };
+         BOOST_STATIC_CONSTANT(
+             result_type,
+             value = !c*n + choose_initial_n<2*c*n>::value
+         );
+
+     };
+
+     template <>
+     struct choose_initial_n<0> {
+         BOOST_STATIC_CONSTANT(result_type, value = 0);
+     };


-//  Implementation details  --------------------------------------------------//

-namespace detail
-{
+     // 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;

-// Forward declarations
-template < unsigned long Val, int Place = 0, int Index
- = std::numeric_limits<unsigned long>::digits >
-    struct static_log2_helper_t;
+     // 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.)
+     //

-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+     template <argument_type x, result_type n = initial_n>
+     struct static_log2_impl {

-template < unsigned long Val, int Place >
-    struct static_log2_helper_t< Val, Place, 1 >;
+         enum { c = (x >> n) > 0 }; // x >= 2**n ?
+         BOOST_STATIC_CONSTANT(
+             result_type,
+             value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)
+         );

-#else
+     };

-template < int Place >
-    struct static_log2_helper_final_step;
+     template <>
+     struct static_log2_impl<1, 0> {
+        BOOST_STATIC_CONSTANT(result_type, value = 0);
+     };

-template < unsigned long Val, int Place = 0, int Index
- = std::numeric_limits<unsigned long>::digits >
-    struct static_log2_helper_nopts_t;
-
-#endif
-
-// Recursively build the logarithm by examining the upper bits
-template < unsigned long Val, int Place, int Index >
-struct static_log2_helper_t
-{
-private:
-    BOOST_STATIC_CONSTANT( int, half_place = Index / 2 );
-    BOOST_STATIC_CONSTANT( unsigned long, lower_mask = (1ul << half_place)
-     - 1ul );
-    BOOST_STATIC_CONSTANT( unsigned long, upper_mask = ~lower_mask );
-    BOOST_STATIC_CONSTANT( bool, do_shift = (Val & upper_mask) != 0ul );
-
-    BOOST_STATIC_CONSTANT( unsigned long, new_val = do_shift ? (Val
-     >> half_place) : Val );
-    BOOST_STATIC_CONSTANT( int, new_place = do_shift ? (Place + half_place)
-     : Place );
-    BOOST_STATIC_CONSTANT( int, new_index = Index - half_place );
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    typedef static_log2_helper_t<new_val, new_place, new_index>  next_step_type;
-#else
-    typedef static_log2_helper_nopts_t<new_val, new_place, new_index>  next_step_type;
-#endif
-
-public:
-    BOOST_STATIC_CONSTANT( int, value = next_step_type::value );
-
-};  // boost::detail::static_log2_helper_t
-
-// Non-recursive case
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-template < unsigned long Val, int Place >
-struct static_log2_helper_t< Val, Place, 1 >
-{
-public:
-    BOOST_STATIC_CONSTANT( int, value = Place );
-
-};  // boost::detail::static_log2_helper_t
-
-#else
-
-template < int Place >
-struct static_log2_helper_final_step
-{
-public:
-    BOOST_STATIC_CONSTANT( int, value = Place );
-
-};  // boost::detail::static_log2_helper_final_step
-
-template < unsigned long Val, int Place, int Index >
-struct static_log2_helper_nopts_t
-{
-private:
-    typedef static_log2_helper_t<Val, Place, Index>  recursive_step_type;
-    typedef static_log2_helper_final_step<Place>     final_step_type;
-
-    typedef typename ct_if<( Index != 1 ), recursive_step_type,
-     final_step_type>::type  next_step_type;
-
-public:
-    BOOST_STATIC_CONSTANT( int, value = next_step_type::value );
-
-};  // boost::detail::static_log2_helper_nopts_t
-
-#endif
-
-}  // namespace detail
+     }
+ } // detail


-//  Compile-time log-base-2 evaluator class declaration  ---------------------//

-template < unsigned long Value >
-struct static_log2
-{
-    BOOST_STATIC_CONSTANT( int, value
-     = detail::static_log2_helper_t<Value>::value );
-};
+ // --------------------------------------
+ // static_log2<x>
+ // ----------------------------------------

-template < >
-struct static_log2< 0ul >
-{
-    // The logarithm of zero is undefined.
-};
+ typedef detail::static_log2_impl::argument_type static_log2_argument_type;
+ typedef detail::static_log2_impl::result_type   static_log2_result_type;


-}  // namespace boost
+ 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
+     );
+
+ };


-#endif  // BOOST_INTEGER_STATIC_LOG2_HPP
+ template <>
+ struct static_log2<0> { };
+
+}
+
+
+
+#endif // include guard
--- a/include/boost/integer_fwd.hpp
+++ b/include/boost/integer_fwd.hpp
@ -6,7 +6,7 @@
 //  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.

 #ifndef BOOST_INTEGER_FWD_HPP
 #define BOOST_INTEGER_FWD_HPP
--- a/include/boost/integer_traits.hpp
+++ b/include/boost/integer_traits.hpp
@ -15,6 +15,9 @@
 * 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

@ -93,12 +96,17 @@ class integer_traits<wchar_t>
 #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)) || (defined __APPLE__) || (defined(__FreeBSD__) && defined(__GNUC__)) || (defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 3) && !defined(__SGI_STL_PORT))
+#elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400))\
+    || (defined __APPLE__)\
+    || (defined(__OpenBSD__) && defined(__GNUC__))\
+    || (defined(__NetBSD__) && defined(__GNUC__))\
+    || (defined(__FreeBSD__) && 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
+    //  - gcc on FreeBSD, OpenBSD and NetBSD
    public detail::integer_traits_base<wchar_t, INT_MIN, INT_MAX>
 #elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT)
    // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int.
@ -147,42 +155,65 @@ class integer_traits<unsigned long>
    public detail::integer_traits_base<unsigned long, 0, ULONG_MAX>
 { };

-#if defined(ULLONG_MAX) && !defined(__SUNPRO_CC)
+#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>
  : public std::numeric_limits<long long>,
    public detail::integer_traits_base<long long, LLONG_MIN, LLONG_MAX>
 { };
+
 template<>
 class integer_traits<unsigned long long>
  : public std::numeric_limits<unsigned long long>,
    public detail::integer_traits_base<unsigned long long, 0, ULLONG_MAX>
 { };
-#elif defined(ULONG_LONG_MAX)
+
+#elif defined(ULONG_LONG_MAX) && defined(BOOST_HAS_LONG_LONG)
+
 template<>
-class integer_traits<long long>
-  : public std::numeric_limits<long long>,
-    public detail::integer_traits_base<long long, LONG_LONG_MIN, LONG_LONG_MAX>
-{ };
+class integer_traits<long long>  : public std::numeric_limits<long long>,    public detail::integer_traits_base<long long, LONG_LONG_MIN, LONG_LONG_MAX>{ };
 template<>
 class integer_traits<unsigned long long>
  : public std::numeric_limits<unsigned long long>,
    public detail::integer_traits_base<unsigned long long, 0, ULONG_LONG_MAX>
 { };
-#elif defined(ULONGLONG_MAX) && !defined(BOOST_MSVC) && !defined(__BORLANDC__)
+
+#elif defined(ULONGLONG_MAX) && defined(BOOST_HAS_LONG_LONG)
+
 template<>
 class integer_traits<long long>
  : public std::numeric_limits<long long>,
    public detail::integer_traits_base<long long, LONGLONG_MIN, LONGLONG_MAX>
 { };
+
 template<>
 class integer_traits<unsigned long long>
  : public std::numeric_limits<unsigned long long>,
    public detail::integer_traits_base<unsigned long long, 0, ULONGLONG_MAX>
 { };
+
+#elif defined(_LLONG_MAX) && defined(_C2) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits<long long>
+  : public std::numeric_limits<long long>,
+    public detail::integer_traits_base<long long, -_LLONG_MAX - _C2, _LLONG_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned long long>
+  : public std::numeric_limits<unsigned long long>,
+    public detail::integer_traits_base<unsigned long long, 0, _ULLONG_MAX>
+{ };
+
+#endif
 #endif

 } // namespace boost

 #endif /* BOOST_INTEGER_TRAITS_HPP */

+
+
--- a/index.htm
+++ b/index.htm
@ -1,128 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<html>
-<head>
-<title>Boost Integer Library</title>
-</head>
-
-<body bgcolor="white" text="black">
-<table border="1" bgcolor="teal" cellpadding="2">
-	<tr>
-		<td bgcolor="white"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
-		<td><a href="../../index.htm"><font face="Arial" color="white"><big>Home</big></font></a></td>
-		<td><a href="../libraries.htm"><font face="Arial" color="white"><big>Libraries</big></font></a></td>
-		<td><a href="../../people/people.htm"><font face="Arial" color="white"><big>People</big></font></a></td>
-		<td><a href="../../more/faq.htm"><font face="Arial" color="white"><big>FAQ</big></font></a></td>
-		<td><a href="../../more/index.htm"><font face="Arial" color="white"><big>More</big></font></a></td>
-	</tr>
-</table>
-
-<h1>Boost Integer Library</h1>
-
-<table border="1" cellpadding="5">
-	<tr>
-		<th>Header / Docs</th>
-		<th>Contents</th>
-		<th>Use</th>
-	</tr>
-	<tr>
-		<td align="center"><cite><a href="../../boost/integer_fwd.hpp">&lt;boost/integer_fwd.hpp&gt;</a></cite></td>
-		<td valign="top">Forward declarations of classes and class templates</td>
-		<td valign="top">When just the name of a class is needed</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>
-	<tr>
-		<td align="center"><code><a href="../../boost/integer/integer_mask.hpp">&lt;boost/integer/integer_mask.hpp&gt;</a><br>
-      <br>
-      </code><a href="doc/integer_mask.html">documentation</a></td>
-		<td valign="top">Templates for the selection of integer masks, single or lowest group, based on the number of bits.</td>
-		<td valign="top">Use to select a particular mask when the bit position(s) are based on a compile-time variable.
-      Useful for generic programming. </td>
-	</tr>
-	<tr>
-		<td align="center"><code><a href="../../boost/integer/static_log2.hpp">&lt;boost/integer/static_log2.hpp&gt;</a><br>
-      <br>
-      </code><a href="doc/static_log2.html">documentation</a></td>
-		<td valign="top">Template for finding the highest power of two in a number.</td>
-		<td valign="top">Use to find the bit-size/range based on a maximum value.
-      Useful for generic programming. </td>
-	</tr>
-	<tr>
-		<td align="center"><code><a href="../../boost/integer/static_min_max.hpp">&lt;boost/integer/static_min_max.hpp&gt;</a><br>
-      <br>
-      </code><a href="doc/static_min_max.html">documentation</a></td>
-		<td valign="top">Templates for finding the extrema of two numbers.</td>
-		<td valign="top">Use to find a bound based on a minimum or maximum value.
-      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 <cite>&lt;stdint.h&gt;</cite> types from the 1999 C
-standard without resorting to undefined behavior in terms of the 1998
-C++ standard.  The header <cite>&lt;boost/cstdint.hpp&gt;</cite> makes
-the standard integer types safely available in namespace
-<code>boost</code> without placing any names in namespace
-<code>std</code>.  As always, the intension is to complement rather than
-compete with the C++ Standard Library.  Should some future C++ standard
-include <cite>&lt;stdint.h&gt;</cite> and <cite>&lt;cstdint&gt;</cite>,
-then <cite>&lt;boost/cstdint.hpp&gt;</cite> 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>
-
-<h2><i>Caveat emptor</i></h2>
-
-<p>As an implementation artifact, certain C
-<cite>&lt;limits.h&gt;</cite> macro names may possibly be visible to
-users of <cite>&lt;boost/cstdint.hpp&gt;</cite>.  Don't use these
-macros; they are not part of any Boost-specified interface.  Use
-<code>boost::integer_traits&lt;&gt;</code> or
-<code>std::numeric_limits&lt;&gt;</code> instead.</p>
-
-<p>As another implementation artifact, certain C
-<cite>&lt;stdint.h&gt;</cite> typedef names may possibly be visible in
-the global namespace to users of <cite>&lt;boost/cstdint.hpp&gt;</cite>.
- Don't use these names, they are not part of any Boost-specified
-interface.  Use the respective names in namespace <code>boost</code>
-instead.</p>
-
-<hr>
-
-<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->03 Oct 2001<!--webbot bot="Timestamp" endspan i-checksum="14373" -->
-</p>
-
-</body>
-</html>
--- a/integer.htm
+++ b/integer.htm
@ -1,213 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<html>
-<head>
-<title>Integer Type Selection Templates</title>
-</head>
-
-<body bgcolor="white" text="black">
-<h1>
-<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
-align="middle" width="277" height="86">Integer Type Selection
-Templates</h1>
-
-<p>The <cite><a
-href="../../boost/integer.hpp">&lt;boost/integer.hpp&gt;</a></cite> 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>
-
-<h2><a name="contents">Contents</a></h2>
-
-<ul>
-	<li><a href="#contents">Contents</a></li>
-	<li><a href="#synopsis">Synopsis</a></li>
-	<li><a href="#easy">Easiest-to-Manipulate Types</a></li>
-	<li><a href="#sized">Sized Types</a></li>
-	<li><a href="#example">Example</a></li>
-	<li><a href="#demo">Demonstration Program</a></li>
-	<li><a href="#rationale">Rationale</a></li>
-	<li><a href="#alternative">Alternative</a></li>
-	<li><a href="#credits">Credits</a></li>
-</ul>
-
-<h2><a name="synopsis">Synopsis</a></h2>
-
-<blockquote><pre>namespace boost
-{
-  //  fast integers from least integers
-  template&lt; typename LeastInt &gt;
-  struct int_fast_t
-  {
-      typedef <em>implementation_supplied</em>  fast;
-  };
-
-  //  signed
-  template&lt; int Bits &gt;
-  struct int_t 
-  {
-      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast  fast;
-  };
-
-  //  unsigned
-  template&lt; int Bits &gt;
-  struct uint_t 
-  {
-      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast  fast;
-  };
-
-  //  signed
-  template&lt; long MaxValue &gt;
-  struct int_max_value_t 
-  {
-      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast  fast;
-  };
-
-  template&lt; long MinValue &gt;
-  struct int_min_value_t 
-  {
-      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast  fast;
-  };
-
-  //  unsigned
-  template&lt; unsigned long Value &gt;
-  struct uint_value_t 
-  {
-      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast  fast;
-  };
-} // namespace boost
-</pre></blockquote>
-
-<h2><a name="easy">Easiest-to-Manipulate Types</a></h2>
-
-<p>The <code>int_fast_t</code> class template maps its input type to the
-next-largest type that the processor can manipulate the easiest, or to
-itself if the input type is already an easy-to-manipulate type.  For
-instance, processing a bunch of <code>char</code> objects may go faster
-if they were converted to <code>int</code> objects before processing. 
-The input type, passed as the only template parameter, must be a
-built-in integral type, except <code>bool</code>.  Unsigned integral
-types can be used, as well as signed integral types, despite the name. 
-The output type is given as the class member <code>fast</code>.</p>
-
-<p><strong>Implementation Notes</strong><br>
-By default, the output type is identical to the input type.  Eventually,
-this code's implementation should be conditionalized 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>
-
-<h2><a name="sized">Sized Types</a></h2>
-
-<p>The <code>int_t</code>, <code>uint_t</code>,
-<code>int_max_value_t</code>, <code>int_min_value_t</code>, and
-<code>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 class member <code>least</code>.  The easiest-to-manipulate
-version of that type is given by the class member <code>fast</code>. 
-The following table describes each template's criteria.</p>
-
-<table border="1" cellpadding="5">
-	<caption>Criteria for the Sized Type Class Templates</caption>
-	<tr>
-		<th>Class Template</th>
-		<th>Template Parameter Mapping</th>
-	</tr>
-	<tr>
-		<td><code>boost::int_t</code></td>
-		<td>The smallest built-in signed integral type with at least the
-			given number of bits, including the sign bit.  The parameter
-			should be a positive number.  A compile-time error results if
-			the parameter is larger than the number of bits in a
-			<code>long</code>.</td>
-	</tr>
-	<tr>
-		<td><code>boost::uint_t</code></td>
-		<td>The smallest built-in unsigned integral type with at least
-			the given number of bits.  The parameter should be a positive
-			number.  A compile-time error results if the parameter is
-			larger than the number of bits in an <code>unsigned
-			long</code>.</td>
-	</tr>
-	<tr>
-		<td><code>boost::int_max_value_t</code></td>
-		<td>The smallest built-in signed integral type that supports the
-			given value as a maximum.  The parameter should be a
-			positive number.</td>
-	</tr>
-	<tr>
-		<td><code>boost::int_min_value_t</code></td>
-		<td>The smallest built-in signed integral type that supports the
-			given value as a minimum.  The parameter should be a
-			negative number.</td>
-	</tr>
-	<tr>
-		<td><code>boost::uint_value_t</code></td>
-		<td>The smallest built-in unsigned integral type that supports
-			the given value as a maximum.  The parameter should be a
-			positive number.</td>
-	</tr>
-</table>
-
-<h2><a name="example">Example</a></h2>
-
-<blockquote><pre>#include &lt;boost/integer.hpp&gt;
-
-//...
-
-int main()
-{
-    boost::int_t&lt;24&gt;::least my_var;
-    //...
-}
-</pre></blockquote>
-
-<h2><a name="demo">Demonstration Program</a></h2>
-
-<p>The program <a href="integer_test.cpp">integer_test.cpp</a> is a
-simplistic demonstration of the results from instantiating various
-examples of the sized type class templates.</p>
-
-<h2><a name="rationale">Rationale</a></h2>
-
-<p>The rationale for the design of the templates in this header includes:</p>
-
-<ul>
-	<li>Avoid 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><a name="alternative">Alternative</a></h2>
-
-<p>If the number of bits required is known beforehand, it may be more
-appropriate to use the types supplied in <cite><a
-href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;</a></cite>.</p>
-
-<h2><a name="credits">Credits</a></h2>
-
-<p>The author of most of the Boost integer type choosing templates is <a
-href="../../people/beman_dawes.html">Beman Dawes</a>.  He gives thanks
-to Valentin Bonnard and
-<a href="../../people/kevlin_henney.htm"> Kevlin Henney</a> for sharing
-their designs for similar templates.  <a
-href="../../people/daryle_walker.html">Daryle Walker</a> designed the
-value-based sized templates.</p>
-
-<hr>
-
-<p>Revised May 20, 2001</p>
-
-<p>&copy; 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>
-</body>
-</html>
--- a/integer_test.cpp
+++ b/integer_test.cpp
@ -1,255 +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
-//   04 Oct 01  Added tests for new templates; rewrote code (Daryle Walker)
-//   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
-//   31 Aug 99  Initial version
-
-#define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main, BOOST_TEST
-
-#include <boost/config.hpp>   // for BOOST_NO_USING_TEMPLATE
-#include <boost/cstdlib.hpp>  // for boost::exit_success
-#include <boost/integer.hpp>  // for boost::int_t, boost::uint_t
-
-#include <climits>   // for ULONG_MAX, LONG_MAX, LONG_MIN
-#include <iostream>  // for std::cout (std::endl indirectly)
-#include <typeinfo>  // for std::type_info
-
-
-// Control if the names of the types for each version
-// of the integer templates will be printed.
-#ifndef CONTROL_SHOW_TYPES
-#define CONTROL_SHOW_TYPES  0
-#endif
-
-
-// If specializations have not already been done, then we can confirm
-// the effects of the "fast" types by making a specialization.
-namespace boost
-{
-    template < >
-    struct int_fast_t< short >
-    {
-        typedef long  fast;
-    };
-}
-
-
-// Show the types of an integer template version
-#if CONTROL_SHOW_TYPES
-#define SHOW_TYPE(Template, Number, Type)  ::std::cout << "Type \"" \
- #Template "<" #Number ">::" #Type "\" is \"" << typeid(Template <  \
- Number > :: Type).name() << ".\"\n"
-#else
-#define SHOW_TYPE(Template, Number, Type)
-#endif
-
-#define SHOW_TYPES(Template, Type)  SHOW_TYPE(Template, 32, Type); \
- SHOW_TYPE(Template, 31, Type); SHOW_TYPE(Template, 30, Type); \
- SHOW_TYPE(Template, 29, Type); SHOW_TYPE(Template, 28, Type); \
- SHOW_TYPE(Template, 27, Type); SHOW_TYPE(Template, 26, Type); \
- SHOW_TYPE(Template, 25, Type); SHOW_TYPE(Template, 24, Type); \
- SHOW_TYPE(Template, 23, Type); SHOW_TYPE(Template, 22, Type); \
- SHOW_TYPE(Template, 21, Type); SHOW_TYPE(Template, 20, Type); \
- SHOW_TYPE(Template, 19, Type); SHOW_TYPE(Template, 18, Type); \
- SHOW_TYPE(Template, 17, Type); SHOW_TYPE(Template, 16, Type); \
- SHOW_TYPE(Template, 15, Type); SHOW_TYPE(Template, 14, Type); \
- SHOW_TYPE(Template, 13, Type); SHOW_TYPE(Template, 12, Type); \
- SHOW_TYPE(Template, 11, Type); SHOW_TYPE(Template, 10, Type); \
- SHOW_TYPE(Template, 9, Type); SHOW_TYPE(Template, 8, Type); \
- SHOW_TYPE(Template, 7, Type); SHOW_TYPE(Template, 6, Type); \
- SHOW_TYPE(Template, 5, Type); SHOW_TYPE(Template, 4, Type); \
- SHOW_TYPE(Template, 3, Type); SHOW_TYPE(Template, 2, Type); \
- SHOW_TYPE(Template, 1, Type); SHOW_TYPE(Template, 0, Type)
-
-#define SHOW_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, (1UL << Number), Type)
-
-#define SHOW_SHIFTED_TYPES(Template, Type)  SHOW_SHIFTED_TYPE(Template, 30, Type); \
- SHOW_SHIFTED_TYPE(Template, 29, Type); SHOW_SHIFTED_TYPE(Template, 28, Type); \
- SHOW_SHIFTED_TYPE(Template, 27, Type); SHOW_SHIFTED_TYPE(Template, 26, Type); \
- SHOW_SHIFTED_TYPE(Template, 25, Type); SHOW_SHIFTED_TYPE(Template, 24, Type); \
- SHOW_SHIFTED_TYPE(Template, 23, Type); SHOW_SHIFTED_TYPE(Template, 22, Type); \
- SHOW_SHIFTED_TYPE(Template, 21, Type); SHOW_SHIFTED_TYPE(Template, 20, Type); \
- SHOW_SHIFTED_TYPE(Template, 19, Type); SHOW_SHIFTED_TYPE(Template, 18, Type); \
- SHOW_SHIFTED_TYPE(Template, 17, Type); SHOW_SHIFTED_TYPE(Template, 16, Type); \
- SHOW_SHIFTED_TYPE(Template, 15, Type); SHOW_SHIFTED_TYPE(Template, 14, Type); \
- SHOW_SHIFTED_TYPE(Template, 13, Type); SHOW_SHIFTED_TYPE(Template, 12, Type); \
- SHOW_SHIFTED_TYPE(Template, 11, Type); SHOW_SHIFTED_TYPE(Template, 10, Type); \
- SHOW_SHIFTED_TYPE(Template, 9, Type); SHOW_SHIFTED_TYPE(Template, 8, Type); \
- SHOW_SHIFTED_TYPE(Template, 7, Type); SHOW_SHIFTED_TYPE(Template, 6, Type); \
- SHOW_SHIFTED_TYPE(Template, 5, Type); SHOW_SHIFTED_TYPE(Template, 4, Type); \
- SHOW_SHIFTED_TYPE(Template, 3, Type); SHOW_SHIFTED_TYPE(Template, 2, Type); \
- SHOW_SHIFTED_TYPE(Template, 1, Type); SHOW_SHIFTED_TYPE(Template, 0, Type)
-
-#define SHOW_POS_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, +(1L << Number), Type)
-
-#define SHOW_POS_SHIFTED_TYPES(Template, Type)  SHOW_POS_SHIFTED_TYPE(Template, 30, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 29, Type); SHOW_POS_SHIFTED_TYPE(Template, 28, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 27, Type); SHOW_POS_SHIFTED_TYPE(Template, 26, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 25, Type); SHOW_POS_SHIFTED_TYPE(Template, 24, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 23, Type); SHOW_POS_SHIFTED_TYPE(Template, 22, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 21, Type); SHOW_POS_SHIFTED_TYPE(Template, 20, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 19, Type); SHOW_POS_SHIFTED_TYPE(Template, 18, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 17, Type); SHOW_POS_SHIFTED_TYPE(Template, 16, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 15, Type); SHOW_POS_SHIFTED_TYPE(Template, 14, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 13, Type); SHOW_POS_SHIFTED_TYPE(Template, 12, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 11, Type); SHOW_POS_SHIFTED_TYPE(Template, 10, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 9, Type); SHOW_POS_SHIFTED_TYPE(Template, 8, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 7, Type); SHOW_POS_SHIFTED_TYPE(Template, 6, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 5, Type); SHOW_POS_SHIFTED_TYPE(Template, 4, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 3, Type); SHOW_POS_SHIFTED_TYPE(Template, 2, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 1, Type); SHOW_POS_SHIFTED_TYPE(Template, 0, Type)
-
-#define SHOW_NEG_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, -(1L << Number), Type)
-
-#define SHOW_NEG_SHIFTED_TYPES(Template, Type)  SHOW_NEG_SHIFTED_TYPE(Template, 30, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 29, Type); SHOW_NEG_SHIFTED_TYPE(Template, 28, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 27, Type); SHOW_NEG_SHIFTED_TYPE(Template, 26, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 25, Type); SHOW_NEG_SHIFTED_TYPE(Template, 24, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 23, Type); SHOW_NEG_SHIFTED_TYPE(Template, 22, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 21, Type); SHOW_NEG_SHIFTED_TYPE(Template, 20, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 19, Type); SHOW_NEG_SHIFTED_TYPE(Template, 18, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 17, Type); SHOW_NEG_SHIFTED_TYPE(Template, 16, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 15, Type); SHOW_NEG_SHIFTED_TYPE(Template, 14, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 13, Type); SHOW_NEG_SHIFTED_TYPE(Template, 12, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 11, Type); SHOW_NEG_SHIFTED_TYPE(Template, 10, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 9, Type); SHOW_NEG_SHIFTED_TYPE(Template, 8, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 7, Type); SHOW_NEG_SHIFTED_TYPE(Template, 6, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 5, Type); SHOW_NEG_SHIFTED_TYPE(Template, 4, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 3, Type); SHOW_NEG_SHIFTED_TYPE(Template, 2, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 1, Type); SHOW_NEG_SHIFTED_TYPE(Template, 0, Type)
-
-
-// Test if a constant can fit within a certain type
-#define PRIVATE_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < Number > :: Type ( Value ) == Value )
-
-#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
-
-#define PRIVATE_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < (ULONG_MAX >> Number) > :: Type ( Value ) == Value )
-
-#define PRIVATE_SHIFTED_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
-
-#define PRIVATE_POS_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < (LONG_MAX >> Number) > :: Type ( Value ) == Value )
-
-#define PRIVATE_POS_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
-
-#define PRIVATE_NEG_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < (LONG_MIN >> Number) > :: Type ( Value ) == Value )
-
-#define PRIVATE_NEG_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
-
-
-// Test program
-int
-test_main
-(
-    int,
-    char*[]
-)
-{
-#ifndef BOOST_NO_USING_TEMPLATE
-    using boost::int_t;
-    using boost::uint_t;
-    using boost::int_max_value_t;
-    using boost::int_min_value_t;
-    using boost::uint_value_t;
-#else
-    using namespace boost;
-#endif
-
-    SHOW_TYPES( int_t, least );
-    SHOW_TYPES( int_t, fast );
-    SHOW_TYPES( uint_t, least );
-    SHOW_TYPES( uint_t, fast );
-    SHOW_POS_SHIFTED_TYPES( int_max_value_t, least );
-    SHOW_POS_SHIFTED_TYPES( int_max_value_t, fast );
-    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, least );
-    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, fast );
-    SHOW_SHIFTED_TYPES( uint_value_t, least );
-    SHOW_SHIFTED_TYPES( uint_value_t, fast );
-     
-    PRIVATE_FIT_TESTS( int_t, least, long, LONG_MAX );
-    PRIVATE_FIT_TESTS( int_t, fast, long, LONG_MAX );
-    PRIVATE_FIT_TESTS( uint_t, least, unsigned long, ULONG_MAX );
-    PRIVATE_FIT_TESTS( uint_t, fast, unsigned long, ULONG_MAX );
-    PRIVATE_POS_FIT_TESTS( int_max_value_t, least, long, LONG_MAX );
-    PRIVATE_POS_FIT_TESTS( int_max_value_t, fast, long, LONG_MAX );
-    PRIVATE_NEG_FIT_TESTS( int_min_value_t, least, long, LONG_MIN );
-    PRIVATE_NEG_FIT_TESTS( int_min_value_t, fast, long, LONG_MIN );
-    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, least, unsigned long, ULONG_MAX );
-    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, fast, unsigned long, ULONG_MAX );
-        
-    return boost::exit_success;
-}
--- a/integer_traits.html
+++ b/integer_traits.html
@ -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/integer_traits_test.cpp
+++ b/integer_traits_test.cpp
@ -1,99 +0,0 @@
-/* boost integer_traits.hpp tests
- *
- * Copyright Jens Maurer 2000
- * Permission to use, copy, modify, sell, and distribute this software
- * is hereby granted without fee provided that the above copyright notice
- * appears in all copies and that both that copyright notice and this
- * permission notice appear in supporting documentation,
- *
- * Jens Maurer makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.
- *
- * $Id$
- *
- * Revision history
- *  2000-02-22  Small improvements by Beman Dawes
- *  2000-06-27  Rework for better MSVC and BCC co-operation
- */
-
-#include <iostream>
-#include <boost/integer_traits.hpp>
-// use int64_t instead of long long for better portability
-#include <boost/cstdint.hpp>
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-
-/*
- * General portability note:
- * MSVC mis-compiles explicit function template instantiations.
- * For example, f<A>() and f<B>() are both compiled to call f<A>().
- * BCC is unable to implicitly convert a "const char *" to a std::string
- * when using explicit function template instantiations.
- *
- * 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 " << make_char_numeric_for_streaming(traits::min())
-            << ", max is " << make_char_numeric_for_streaming(traits::max())
-            << std::endl;
-  BOOST_TEST(traits::is_specialized);
-  BOOST_TEST(traits::is_integer);
-  BOOST_TEST(traits::is_integral);
-  BOOST_TEST(traits::const_min == traits::min());
-  BOOST_TEST(traits::const_max == traits::max());
-}
-
-int test_main(int, char*[])
-{
-  runtest("bool", bool());
-  runtest("char", char());
-  typedef signed char signed_char;
-  runtest("signed char", signed_char());
-  typedef unsigned char unsigned_char;
-  runtest("unsigned char", unsigned_char());
-  runtest("wchar_t", wchar_t());
-  runtest("short", short());
-  typedef unsigned short unsigned_short;
-  runtest("unsigned short", unsigned_short());
-  runtest("int", int());
-  typedef unsigned int unsigned_int;
-  runtest("unsigned int", unsigned_int());
-  runtest("long", long());
-  typedef unsigned long unsigned_long;
-  runtest("unsigned long", unsigned_long());
-#if !defined(BOOST_NO_INT64_T) && (!defined(BOOST_MSVC) || BOOST_MSVC > 1300) && !defined(__BORLANDC__) && !defined(__BEOS__)
-  //
-  // MS/Borland compilers can't support 64-bit member constants
-  // BeOS doesn't have specialisations for long long in SGI's <limits> header.
-  runtest("int64_t (possibly long long)", boost::int64_t());
-  runtest("uint64_t (possibly unsigned long long)", boost::uint64_t());
-#else
-  std::cout << "Skipped int64_t and uint64_t" << std::endl;
-#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;
-}
-
--- a/test/integer_mask_test.cpp
+++ b/test/integer_mask_test.cpp
@ -1,112 +0,0 @@
-//  boost integer_mask.hpp test program  -------------------------------------//
-
-//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell
-//  and distribute this software is granted provided this copyright
-//  notice appears in all copies.  This software is provided "as is" without
-//  express or implied warranty, and with no claim as to its suitability for
-//  any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Revision History
-//  23 Sep 2001  Initial version (Daryle Walker)
-
-#define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main
-
-#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)
-
-
-#define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
- (v) >::high_bit == (1ul << (v)) );
-#define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
- (v) >::high_bit_fast == (1ul << (v)) );
-#define PRIVATE_HIGH_BIT_TEST(v)  do { PRIVATE_HIGH_BIT_SLOW_TEST(v); \
- PRIVATE_HIGH_BIT_FAST_TEST(v); } while (false)
-
-#define PRIVATE_LOW_BITS_SLOW_TEST(v)  BOOST_TEST( ::boost::low_bits_mask_t< \
- (v) >::sig_bits == ((1ul << (v)) - 1) );
-#define PRIVATE_LOW_BITS_FAST_TEST(v)  BOOST_TEST( ::boost::low_bits_mask_t< \
- (v) >::sig_bits_fast == ((1ul << (v)) - 1) );
-#define PRIVATE_LOW_BITS_TEST(v)  do { PRIVATE_LOW_BITS_SLOW_TEST(v); \
- PRIVATE_LOW_BITS_FAST_TEST(v); } while (false)
-
-
-int test_main( int, char*[] )
-{
-    using std::cout;
-    using std::endl;
-
-    cout << "Doing high_bit_mask_t tests." << endl;
-    PRIVATE_HIGH_BIT_TEST( 31 );
-    PRIVATE_HIGH_BIT_TEST( 30 );
-    PRIVATE_HIGH_BIT_TEST( 29 );
-    PRIVATE_HIGH_BIT_TEST( 28 );
-    PRIVATE_HIGH_BIT_TEST( 27 );
-    PRIVATE_HIGH_BIT_TEST( 26 );
-    PRIVATE_HIGH_BIT_TEST( 25 );
-    PRIVATE_HIGH_BIT_TEST( 24 );
-    PRIVATE_HIGH_BIT_TEST( 23 );
-    PRIVATE_HIGH_BIT_TEST( 22 );
-    PRIVATE_HIGH_BIT_TEST( 21 );
-    PRIVATE_HIGH_BIT_TEST( 20 );
-    PRIVATE_HIGH_BIT_TEST( 19 );
-    PRIVATE_HIGH_BIT_TEST( 18 );
-    PRIVATE_HIGH_BIT_TEST( 17 );
-    PRIVATE_HIGH_BIT_TEST( 16 );
-    PRIVATE_HIGH_BIT_TEST( 15 );
-    PRIVATE_HIGH_BIT_TEST( 14 );
-    PRIVATE_HIGH_BIT_TEST( 13 );
-    PRIVATE_HIGH_BIT_TEST( 12 );
-    PRIVATE_HIGH_BIT_TEST( 11 );
-    PRIVATE_HIGH_BIT_TEST( 10 );
-    PRIVATE_HIGH_BIT_TEST(  9 );
-    PRIVATE_HIGH_BIT_TEST(  8 );
-    PRIVATE_HIGH_BIT_TEST(  7 );
-    PRIVATE_HIGH_BIT_TEST(  6 );
-    PRIVATE_HIGH_BIT_TEST(  5 );
-    PRIVATE_HIGH_BIT_TEST(  4 );
-    PRIVATE_HIGH_BIT_TEST(  3 );
-    PRIVATE_HIGH_BIT_TEST(  2 );
-    PRIVATE_HIGH_BIT_TEST(  1 );
-    PRIVATE_HIGH_BIT_TEST(  0 );
-
-    cout << "Doing low_bits_mask_t tests." << endl;
-    PRIVATE_LOW_BITS_TEST( 32 );  // Undefined behavior?  Whoops!
-    PRIVATE_LOW_BITS_TEST( 31 );
-    PRIVATE_LOW_BITS_TEST( 30 );
-    PRIVATE_LOW_BITS_TEST( 29 );
-    PRIVATE_LOW_BITS_TEST( 28 );
-    PRIVATE_LOW_BITS_TEST( 27 );
-    PRIVATE_LOW_BITS_TEST( 26 );
-    PRIVATE_LOW_BITS_TEST( 25 );
-    PRIVATE_LOW_BITS_TEST( 24 );
-    PRIVATE_LOW_BITS_TEST( 23 );
-    PRIVATE_LOW_BITS_TEST( 22 );
-    PRIVATE_LOW_BITS_TEST( 21 );
-    PRIVATE_LOW_BITS_TEST( 20 );
-    PRIVATE_LOW_BITS_TEST( 19 );
-    PRIVATE_LOW_BITS_TEST( 18 );
-    PRIVATE_LOW_BITS_TEST( 17 );
-    PRIVATE_LOW_BITS_TEST( 16 );
-    PRIVATE_LOW_BITS_TEST( 15 );
-    PRIVATE_LOW_BITS_TEST( 14 );
-    PRIVATE_LOW_BITS_TEST( 13 );
-    PRIVATE_LOW_BITS_TEST( 12 );
-    PRIVATE_LOW_BITS_TEST( 11 );
-    PRIVATE_LOW_BITS_TEST( 10 );
-    PRIVATE_LOW_BITS_TEST(  9 );
-    PRIVATE_LOW_BITS_TEST(  8 );
-    PRIVATE_LOW_BITS_TEST(  7 );
-    PRIVATE_LOW_BITS_TEST(  6 );
-    PRIVATE_LOW_BITS_TEST(  5 );
-    PRIVATE_LOW_BITS_TEST(  4 );
-    PRIVATE_LOW_BITS_TEST(  3 );
-    PRIVATE_LOW_BITS_TEST(  2 );
-    PRIVATE_LOW_BITS_TEST(  1 );
-
-    return boost::exit_success;
-}
--- a/test/static_log2_test.cpp
+++ b/test/static_log2_test.cpp
@ -1,151 +0,0 @@
-//  Boost static_log2.hpp test program  --------------------------------------//
-
-//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell
-//  and distribute this software is granted provided this copyright
-//  notice appears in all copies.  This software is provided "as is" without
-//  express or implied warranty, and with no claim as to its suitability for
-//  any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Revision History
-//  01 Oct 2001  Initial version (Daryle Walker)
-
-#define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.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
-test_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::exit_success;
-}
--- a/test/static_min_max_test.cpp
+++ b/test/static_min_max_test.cpp
@ -1,94 +0,0 @@
-//  Boost static_min_max.hpp test program  -----------------------------------//
-
-//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell
-//  and distribute this software is granted provided this copyright
-//  notice appears in all copies.  This software is provided "as is" without
-//  express or implied warranty, and with no claim as to its suitability for
-//  any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Revision History
-//  23 Sep 2001  Initial version (Daryle Walker)
-
-#define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main, BOOST_TEST
-
-#include <boost/cstdlib.hpp>                 // for boost::exit_success
-#include <boost/integer/static_min_max.hpp>  // for boost::static_signed_min, etc.
-
-#include <iostream>  // for std::cout (std::endl indirectly)
-
-
-// Main testing function
-int
-test_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::exit_success;
-}
Author	SHA1	Message	Date
nobody	fd3546a6db	This commit was manufactured by cvs2svn to create branch 'SPIRIT_1_6'. [SVN r23968]	2004-07-23 02:16:28 +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