[Boost-commit] svn:boost r61729 - in sandbox/SOC/2010/bits_and_ints: boost/integer libs/integer/doc libs/integer/doc/html libs/integer/test

Subject: [Boost-commit] svn:boost r61729 - in sandbox/SOC/2010/bits_and_ints: boost/integer libs/integer/doc libs/integer/doc/html libs/integer/test
From: muriloufg_at_[hidden]
Date: 2010-05-01 23:45:52

Author: murilov
Date: 2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
New Revision: 61729
URL: http://svn.boost.org/trac/boost/changeset/61729

Log:
- Uploading the original Boost.Integer library
Added:
   sandbox/SOC/2010/bits_and_ints/boost/integer/integer_mask.hpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/boost/integer/static_log2.hpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/boost/integer/static_min_max.hpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/doc/Jamfile.v2   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/doc/html/index.html   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/doc/integer.qbk   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/Jamfile.v2   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/cstdint_include_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/cstdint_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/cstdint_test2.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_fwd_include_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_include_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_mask_include_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_mask_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_traits_include_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_traits_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_log2_include_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_log2_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_min_max_include_test.cpp   (contents, props changed)
   sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_min_max_test.cpp   (contents, props changed)

Added: sandbox/SOC/2010/bits_and_ints/boost/integer/integer_mask.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/boost/integer/integer_mask.hpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,102 @@
+//  Boost integer/integer_mask.hpp header file  ------------------------------//
+
+//  (C) Copyright Daryle Walker 2001.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history. 
+
+#ifndef BOOST_INTEGER_INTEGER_MASK_HPP
+#define BOOST_INTEGER_INTEGER_MASK_HPP
+
+#include <boost/integer_fwd.hpp>  // self include
+
+#include <boost/config.hpp>   // for BOOST_STATIC_CONSTANT
+#include <boost/integer.hpp>  // for boost::uint_t
+
+#include <climits>  // for UCHAR_MAX, etc.
+#include <cstddef>  // for std::size_t
+
+#include <boost/limits.hpp>  // for std::numeric_limits
+
+
+namespace boost
+{
+
+
+//  Specified single-bit mask class declaration  -----------------------------//
+//  (Lowest bit starts counting at 0.)
+
+template < std::size_t Bit >
+struct high_bit_mask_t
+{
+    typedef typename uint_t<(Bit + 1)>::least  least;
+    typedef typename uint_t<(Bit + 1)>::fast   fast;
+
+    BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << Bit) );
+    BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << Bit) );
+
+    BOOST_STATIC_CONSTANT( std::size_t, bit_position = Bit );
+
+};  // boost::high_bit_mask_t
+
+
+//  Specified bit-block mask class declaration  ------------------------------//
+//  Makes masks for the lowest N bits
+//  (Specializations are needed when N fills up a type.)
+
+template < std::size_t Bits >
+struct low_bits_mask_t
+{
+    typedef typename uint_t<Bits>::least  least;
+    typedef typename uint_t<Bits>::fast   fast;
+
+    BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
+    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
+
+    BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
+
+};  // boost::low_bits_mask_t
+
+
+#define BOOST_LOW_BITS_MASK_SPECIALIZE( Type )                                  \
+  template <  >  struct low_bits_mask_t< std::numeric_limits<Type>::digits >  { \
+      typedef std::numeric_limits<Type>           limits_type;                  \
+      typedef uint_t<limits_type::digits>::least  least;                        \
+      typedef uint_t<limits_type::digits>::fast   fast;                         \
+      BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) );              \
+      BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );            \
+      BOOST_STATIC_CONSTANT( std::size_t, bit_count = limits_type::digits );    \
+  }
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4245)  // 'initializing' : conversion from 'int' to 'const boost::low_bits_mask_t<8>::least', signed/unsigned mismatch
+#endif
+
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned char );
+
+#if USHRT_MAX > UCHAR_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned short );
+#endif
+
+#if UINT_MAX > USHRT_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned int );
+#endif
+
+#if ULONG_MAX > UINT_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned long );
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#undef BOOST_LOW_BITS_MASK_SPECIALIZE
+
+
+}  // namespace boost
+
+
+#endif  // BOOST_INTEGER_INTEGER_MASK_HPP

Added: sandbox/SOC/2010/bits_and_ints/boost/integer/static_log2.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/boost/integer/static_log2.hpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,127 @@
+// -------------- Boost static_log2.hpp header file  ----------------------- //
+//
+//                 Copyright (C) 2001 Daryle Walker.
+//                 Copyright (C) 2003 Vesa Karvonen.
+//                 Copyright (C) 2003 Gennaro Prota.
+//
+//     Distributed under the Boost Software License, Version 1.0.
+//        (See accompanying file LICENSE_1_0.txt or copy at
+//              http://www.boost.org/LICENSE_1_0.txt)
+//
+//         ---------------------------------------------------
+//       See http://www.boost.org/libs/integer for documentation.
+// ------------------------------------------------------------------------- //
+
+
+#ifndef BOOST_INTEGER_STATIC_LOG2_HPP
+#define BOOST_INTEGER_STATIC_LOG2_HPP
+
+#include "boost/integer_fwd.hpp" // for boost::intmax_t
+
+namespace boost {
+
+ namespace detail {
+
+     namespace static_log2_impl {
+
+     // choose_initial_n<>
+     //
+     // Recursively doubles its integer argument, until it
+     // becomes >= of the "width" (C99, 6.2.6.2p4) of
+     // static_log2_argument_type.
+     //
+     // Used to get the maximum power of two less then the width.
+     //
+     // Example: if on your platform argument_type has 48 value
+     //          bits it yields n=32.
+     //
+     // It's easy to prove that, starting from such a value
+     // of n, the core algorithm works correctly for any width
+     // of static_log2_argument_type and that recursion always
+     // terminates with x = 1 and n = 0 (see the algorithm's
+     // invariant).
+
+     typedef boost::static_log2_argument_type argument_type;
+     typedef boost::static_log2_result_type result_type;
+
+     template <result_type n>
+     struct choose_initial_n {
+
+         BOOST_STATIC_CONSTANT(bool, c = (argument_type(1) << n << n) != 0);
+         BOOST_STATIC_CONSTANT(
+             result_type,
+             value = !c*n + choose_initial_n<2*c*n>::value
+         );
+
+     };
+
+     template <>
+     struct choose_initial_n<0> {
+         BOOST_STATIC_CONSTANT(result_type, value = 0);
+     };
+
+
+
+     // start computing from n_zero - must be a power of two
+     const result_type n_zero = 16;
+     const result_type initial_n = choose_initial_n<n_zero>::value;
+
+     // static_log2_impl<>
+     //
+     // * Invariant:
+     //                 2n
+     //  1 <= x && x < 2    at the start of each recursion
+     //                     (see also choose_initial_n<>)
+     //
+     // * Type requirements:
+     //
+     //   argument_type maybe any unsigned type with at least n_zero + 1
+     //   value bits. (Note: If larger types will be standardized -e.g.
+     //   unsigned long long- then the argument_type typedef can be
+     //   changed without affecting the rest of the code.)
+     //
+
+     template <argument_type x, result_type n = initial_n>
+     struct static_log2_impl {
+
+         BOOST_STATIC_CONSTANT(bool, c = (x >> n) > 0); // x >= 2**n ?
+         BOOST_STATIC_CONSTANT(
+             result_type,
+             value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)
+         );
+
+     };
+
+     template <>
+     struct static_log2_impl<1, 0> {
+        BOOST_STATIC_CONSTANT(result_type, value = 0);
+     };
+
+     }
+ } // detail
+
+
+
+ // --------------------------------------
+ // static_log2<x>
+ // ----------------------------------------
+
+ template <static_log2_argument_type x>
+ struct static_log2 {
+
+     BOOST_STATIC_CONSTANT(
+         static_log2_result_type,
+         value = detail::static_log2_impl::static_log2_impl<x>::value
+     );
+
+ };
+
+
+ template <>
+ struct static_log2<0> { };
+
+}
+
+
+
+#endif // include guard

Added: sandbox/SOC/2010/bits_and_ints/boost/integer/static_min_max.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/boost/integer/static_min_max.hpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,51 @@
+//  Boost integer/static_min_max.hpp header file  ----------------------------//
+
+//  (C) Copyright Daryle Walker 2001.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history. 
+
+#ifndef BOOST_INTEGER_STATIC_MIN_MAX_HPP
+#define BOOST_INTEGER_STATIC_MIN_MAX_HPP
+
+#include <boost/integer_fwd.hpp>  // self include
+
+namespace boost
+{
+
+//  Compile-time extrema class declarations  ---------------------------------//
+//  Get the minimum or maximum of two values, signed or unsigned.
+
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+struct static_signed_min
+{
+    BOOST_STATIC_CONSTANT(static_min_max_signed_type, value = (Value1 > Value2) ? Value2 : Value1 );
+};
+
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+struct static_signed_max
+{
+    BOOST_STATIC_CONSTANT(static_min_max_signed_type, value = (Value1 < Value2) ? Value2 : Value1 );
+};
+
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+struct static_unsigned_min
+{
+    BOOST_STATIC_CONSTANT(static_min_max_unsigned_type, value
+     = (Value1 > Value2) ? Value2 : Value1 );
+};
+
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+struct static_unsigned_max
+{
+    BOOST_STATIC_CONSTANT(static_min_max_unsigned_type, value
+     = (Value1 < Value2) ? Value2 : Value1 );
+};
+
+
+}  // namespace boost
+
+
+#endif  // BOOST_INTEGER_STATIC_MIN_MAX_HPP

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/doc/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/doc/Jamfile.v2	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,59 @@
+
+
+# Copyright John Maddock 2005. Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+using quickbook ;
+
+xml integer : integer.qbk ;
+boostbook standalone
+    :
+        integer
+    :
+        # HTML options first:
+        # Use graphics not text for navigation:
+        <xsl:param>navig.graphics=1
+        # How far down we chunk nested sections, basically all of them:
+        <xsl:param>chunk.section.depth=1
+        # Don't put the first section on the same page as the TOC:
+        <xsl:param>chunk.first.sections=0
+        # How far down sections get TOC's
+        <xsl:param>toc.section.depth=1
+        # Max depth in each TOC:
+        <xsl:param>toc.max.depth=1
+        # How far down we go with TOC's
+        <xsl:param>generate.section.toc.level=4
+        # Path for links to Boost:
+        <xsl:param>boost.root=../../../..
+        # Path for libraries index:
+        <xsl:param>boost.libraries=../../../../libs/libraries.htm
+        # Use the main Boost stylesheet:
+        <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
+        
+        # PDF Options:
+        # TOC Generation: this is needed for FOP-0.9 and later:
+        <xsl:param>fop1.extensions=0
+        # Or enable this if you're using XEP:
+        <xsl:param>xep.extensions=1
+        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+        <xsl:param>fop.extensions=0
+        # No indent on body text:
+        <xsl:param>body.start.indent=0pt
+        # Margin size:
+        <xsl:param>page.margin.inner=0.5in
+        # Margin size:
+        <xsl:param>page.margin.outer=0.5in
+        # Yes, we want graphics for admonishments:
+        <xsl:param>admon.graphics=1
+        # Set this one for PDF generation *only*:
+        # default pnd graphics are awful in PDF form,
+        # better use SVG's instead:
+        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/regex/doc/html
+    ;
+
+install pdf-install : standalone : <location>. <install-type>PDF ;
+
+

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/doc/html/index.html
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/doc/html/index.html	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,246 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Boost.Integer</title>
+<link rel="stylesheet" href="../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="index.html" title="Boost.Integer">
+<link rel="next" href="boost_integer/cstdint.html" title="Standard Integer Types">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="boost_integer/cstdint.html"><img src="../../../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="article" title="Boost.Integer">
+<div class="titlepage">
+<div>
+<div><h2 class="title">
+<a name="boost_integer"></a>Boost.Integer</h2></div>
+<div><div class="authorgroup">
+<div class="author"><h3 class="author">
+<span class="firstname">Beman</span> <span class="surname">Dawes</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">Daryle</span> <span class="surname">Walker</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">Gennaro</span> <span class="surname">Prota</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">John</span> <span class="surname">Maddock</span>
+</h3></div>
+</div></div>
+<div><p class="copyright">Copyright &#169; 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota,
+      John Maddock</p></div>
+<div><div class="legalnotice" title="Legal Notice">
+<a name="id36182844"></a><p>
+        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)
+      </p>
+</div></div>
+</div>
+<hr>
+</div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<dl>
+<dt><span class="section"> Overview</span></dt>
+<dt><span class="section"> Standard Integer Types</span></dt>
+<dt><span class="section"> Integer Traits</span></dt>
+<dt><span class="section"> Integer Type Selection</span></dt>
+<dt><span class="section"> Integer Masks</span></dt>
+<dt><span class="section"> Compile Time log2 Calculation</span></dt>
+<dt><span class="section"> Compile time min/max calculation</span></dt>
+<dt><span class="section"> History</span></dt>
+</dl>
+</div>
+<div class="section" title="Overview">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.overview"></a><a class="link" href="index.html#boost_integer.overview" title="Overview"> Overview</a>
+</h2></div></div></div>
+<p>
+      Boost.Integer provides integer type support, particularly helpful in generic
+      programming. It provides standard C99 integer types, such as might be found
+      in &lt;stdint.h&gt;, without requiring that header. It provides the means to
+      select an integer type based upon its properties, like the number of bits or
+      the maximum supported value, as well as compile-time bit mask selection. There
+      is a derivative of std::numeric_limits that provides integral constant expressions
+      for <code class="computeroutput"><span class="identifier">min</span></code> and <code class="computeroutput"><span class="identifier">max</span></code>.
+      Finally, it provides two compile-time algorithms: determining the highest power
+      of two in a compile-time value; and computing min and max of constant expressions.
+    </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+            <p>
+              Component
+            </p>
+            </th>
+<th>
+            <p>
+              Header
+            </p>
+            </th>
+<th>
+            <p>
+              Purpose
+            </p>
+            </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+            <p>
+              Forward Declarations.
+            </p>
+            </td>
+<td>
+            <p>
+              <code class="literal"><boost/integer_fwd.hpp></code>
+            </p>
+            </td>
+<td>
+            <p>
+              Forward declarations of classes and class templates - for use when
+              just the name of a class is needed.
+            </p>
+            </td>
+</tr>
+<tr>
+<td>
+            <p>
+              <a class="link" href="boost_integer/cstdint.html" title="Standard Integer Types">Standard Integer Types</a>.
+            </p>
+            </td>
+<td>
+            <p>
+              <code class="literal"><boost/cstdint.hpp></code>
+            </p>
+            </td>
+<td>
+            <p>
+              Provides typedef's based on the 1999 C Standard header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">stdint</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span></code>, wrapped in namespace boost. This
+              implementation may #include the compiler supplied <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">stdint</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span></code>,
+              if present.
+            </p>
+            </td>
+</tr>
+<tr>
+<td>
+            <p>
+              <a class="link" href="boost_integer/traits.html" title="Integer Traits">Integer Traits</a>.
+            </p>
+            </td>
+<td>
+            <p>
+              <code class="literal"><boost/integer_traits.hpp></code>
+            </p>
+            </td>
+<td>
+            <p>
+              Class template <code class="literal">boost::integer_traits</code>, derives from
+              <code class="literal">std::numeric_limits</code> and adds <code class="literal">const_min</code>
+              and <code class="literal">const_max</code> members.
+            </p>
+            </td>
+</tr>
+<tr>
+<td>
+            <p>
+              <a class="link" href="boost_integer/integer.html" title="Integer Type Selection">Integer Type Selection</a>.
+            </p>
+            </td>
+<td>
+            <p>
+              <code class="literal"><boost/integer.hpp></code>
+            </p>
+            </td>
+<td>
+            <p>
+              Templates for integer type selection based on properties such as maximum
+              value or number of bits: Use to select the type of an integer when
+              some property such as maximum value or number of bits is known. Useful
+              for generic programming.
+            </p>
+            </td>
+</tr>
+<tr>
+<td>
+            <p>
+              <a class="link" href="boost_integer/mask.html" title="Integer Masks">Integer Masks</a>.
+            </p>
+            </td>
+<td>
+            <p>
+              <code class="literal"><boost/integer/integer_mask.hpp></code>
+            </p>
+            </td>
+<td>
+            <p>
+              Templates for the selection of integer masks, single or lowest group,
+              based on the number of bits: Use to select a particular mask when the
+              bit position(s) are based on a compile-time variable. Useful for generic
+              programming.
+            </p>
+            </td>
+</tr>
+<tr>
+<td>
+            <p>
+              <a class="link" href="boost_integer/log2.html" title="Compile Time log2 Calculation">Compile time log2 Calculation</a>.
+            </p>
+            </td>
+<td>
+            <p>
+              <code class="literal"><boost/integer/static_log2.hpp></code>
+            </p>
+            </td>
+<td>
+            <p>
+              Template for finding the highest power of two in a number: Use to find
+              the bit-size/range based on a maximum value. Useful for generic programming.
+            </p>
+            </td>
+</tr>
+<tr>
+<td>
+            <p>
+              <a class="link" href="boost_integer/minmax.html" title="Compile time min/max calculation">Compile time min/max calculation</a>.
+            </p>
+            </td>
+<td>
+            <p>
+              <code class="literal"><boost/integer/static_min_max.hpp></code>
+            </p>
+            </td>
+<td>
+            <p>
+              Templates for finding the extrema of two numbers: Use to find a bound
+              based on a minimum or maximum value. Useful for generic programming.
+            </p>
+            </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"><p><small>Last revised: May 02, 2010 at 02:23:56 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="boost_integer/cstdint.html"><img src="../../../../doc/html/images/next.png" alt="Next"></a></div>
+</body>
+</html>

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/doc/integer.qbk
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/doc/integer.qbk	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,840 @@
+[article Boost.Integer
+    [quickbook 1.5]
+    [copyright 2001-2009 Beman Dawes, Daryle Walker, Gennaro Prota, John Maddock]
+    [purpose Integer Type Selection]
+    [license
+        Distributed under the Boost Software License, Version 1.0.
+        (See accompanying file LICENSE_1_0.txt or copy at
+        [@http://www.boost.org/LICENSE_1_0.txt])
+    ]
+    [authors [Dawes, Beman], [Walker, Daryle], [Prota, Gennaro], [Maddock, John]]
+    [/last-revision $Date: 2008-02-21 12:58:15 +0000 (Thu, 21 Feb 2008) $]
+]
+
+[template super[x]'''<superscript>'''[x]'''</superscript>''']
+
+[section:overview Overview]
+
+Boost.Integer provides integer type support, particularly helpful in generic programming.  It provides standard 
+C99 integer types, such as might be found in <stdint.h>, without requiring that header.  
+It provides the means to select an integer type based upon its properties, like the number of bits or 
+the maximum supported value, as well as compile-time bit mask selection.  There is a derivative of
+std::numeric_limits that provides integral constant expressions for `min` and `max`.  
+Finally, it provides two compile-time algorithms: determining the highest power of two in a 
+compile-time value; and computing min and max of constant expressions.
+
+[table 
+   [[Component][Header][Purpose]]
+   [
+      [Forward Declarations.]
+      [[^[@../../../../boost/integer_fwd.hpp <boost/integer_fwd.hpp>]]]
+      [Forward declarations of classes and class templates - for use when just the name of a class is needed.]
+   ]
+   [
+      [[link boost_integer.cstdint Standard Integer Types].]
+      [[^[@../../../../boost/cstdint.hpp <boost/cstdint.hpp>]]]
+      [Provides typedef's based on the 1999 C Standard header `<stdint.h>`, wrapped in namespace boost. 
+      This implementation may #include the compiler supplied `<stdint.h>`, if present.]
+   ]
+   [
+      [[link boost_integer.traits Integer Traits].]
+      [[^[@../../../../boost/integer_traits.hpp <boost/integer_traits.hpp>]]]
+      [Class template [^boost::integer_traits], derives from [^std::numeric_limits] and adds [^const_min] and [^const_max] members.]
+   ]
+   [
+      [[link boost_integer.integer Integer Type Selection].]
+      [[^[@../../../../boost/hpp <boost/integer.hpp>]]]
+      [Templates for integer type selection based on properties such as maximum value or number of bits: 
+      Use to select the type of an integer when some property such as maximum value or number of bits is known. 
+      Useful for generic programming. ]
+   ]
+   [
+      [[link boost_integer.mask Integer Masks].]
+      [[^[@../../../../boost/integer/integer_mask.hpp <boost/integer/integer_mask.hpp>]]]
+      [Templates for the selection of integer masks, single or lowest group, based on the number of bits: 
+      Use to select a particular mask when the bit position(s) are based on a compile-time variable. Useful for generic programming. ]
+   ]
+   [
+      [[link boost_integer.log2 Compile time log2 Calculation].]
+      [[^[@../../../../boost/integer/static_log2.hpp <boost/integer/static_log2.hpp>]]]
+      [Template for finding the highest power of two in a number: 
+      Use to find the bit-size/range based on a maximum value. Useful for generic programming. ]
+   ]
+   [
+      [[link boost_integer.minmax Compile time min/max calculation].]
+      [[^[@../../../../boost/integer/static_min_max.hpp <boost/integer/static_min_max.hpp>]]]
+      [Templates for finding the extrema of two numbers: 
+      Use to find a bound based on a minimum or maximum value. Useful for generic programming. ]
+   ]
+]
+
+[endsect]
+
+[section:cstdint Standard Integer Types]
+
+[section Overview]
+
+The header [^[@../../../../boost/cstdint.hpp <boost/cstdint.hpp>]] provides the typedef's useful 
+for writing portable code that requires certain integer widths. All typedef's are in namespace boost.
+
+The specifications for these types are based on the ISO/IEC 9899:1999 C Language standard header <stdint.h>.  
+The 64-bit types required by the C standard are ['not required] in the boost header, 
+and may not be supplied for all platforms/compilers, because [^long long] is not [yet] included in the C++ standard.
+
+See [@../../test/cstdint_test.cpp cstdint_test.cpp] for a test program.
+
+[endsect]
+
+[section:rationale Rationale]
+
+The organization of the Boost.Integer headers and classes is designed to take advantage of <stdint.h> types from the 
+1999 C standard without causing undefined behavior in terms of the 1998 C++ standard. 
+The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace [^boost] 
+without placing any names in namespace [^std]. The intension is to complement rather than compete 
+with the C++ Standard Library. Should some future C++ standard include <stdint.h> and <cstdint>, 
+then <boost/cstdint.hpp> will continue to function, but will become redundant and may be safely deprecated.
+
+Because these are boost headers, their names conform to boost header naming conventions rather than 
+C++ Standard Library header naming conventions.
+
+[endsect]
+
+[section:ce ['Caveat emptor]]
+
+As an implementation artifact, certain C <limits.h> macro names may possibly be 
+visible to users of <boost/cstdint.hpp>. Don't use these macros; they are not part of 
+any Boost-specified interface. Use [^boost::integer_traits<>] or [^std::numeric_limits<>] instead.
+
+As another implementation artifact, certain C <stdint.h> typedef names may possibly be visible 
+in the global namespace to users of <boost/cstdint.hpp>. Don't use these names, they are not part of 
+any Boost-specified interface. Use the respective names in namespace [^boost] instead.
+
+[endsect]
+
+[section Exact-width integer types]
+
+The typedef [^int#_t], with # replaced by the width, designates a signed integer type of exactly # bits; 
+for example [^int8_t] denotes an 8-bit signed integer type.  Similarly, the typedef [^uint#_t] designates an unsigned 
+integer type of exactly # bits.
+
+These types are optional. However, if a platform supports integer types with widths of 
+8, 16, 32, 64, or any combination thereof, then <boost/cstdint.hpp> does provide the 
+corresponding typedefs.
+
+The absence of int64_t and uint64_t is indicated by the macro `BOOST_NO_INT64_T`.
+
+[endsect] 
+
+[section Minimum-width integer types]
+
+The typedef [^int_least#_t], with # replaced by the width,  designates a signed integer type with a width 
+of at least # bits, such that no signed integer type with lesser size has at least the specified width. 
+Thus, [^int_least32_t] denotes the smallest signed integer type with a width of at least 32 bits. 
+Similarly, the typedef name [^uint_least#_t] designates an unsigned integer type with a width of at least # bits, 
+such that no unsigned integer type with lesser size has at least the specified width.
+
+The following minimum-width integer types are provided for all platforms:
+
+* [^int_least8_t]
+* [^int_least16_t]
+* [^int_least32_t]
+* [^uint_least8_t]
+* [^uint_least16_t]
+* [^uint_least32_t]
+
+The following types are available only if, after including <boost/cstdint.hpp>, the macro BOOST_NO_INT64_T is not defined:
+
+* [^int_least64_t]
+* [^uint_least64_t]
+
+
+All other minimum-width integer types are optional.
+
+[endsect] 
+
+[section Fastest minimum-width integer types]
+
+The typedef [^int_fast#_t], with # replaced by the width, designates the fastest signed integer type 
+with a width of at least # bits. Similarly, the typedef name [^uint_fast#_t] designates the fastest 
+unsigned integer type with a width of at least # bits.
+
+There is no guarantee that these types are fastest for all purposes.  In any case, however, they satisfy  
+the signedness and width requirements.
+
+The following fastest minimum-width integer types are provided for all platforms:
+
+* [^int_fast8_t]
+* [^int_fast16_t]
+* [^int_fast32_t]
+* [^uint_fast8_t]
+* [^uint_fast16_t]
+* [^uint_fast32_t]
+
+The following types are available only if, after including <boost/cstdint.hpp>, the macro BOOST_NO_INT64_T is not defined:
+
+* [^int_fast64_t]
+* [^uint_fast64_t]
+
+All other fastest minimum-width integer types are optional.
+
+[endsect] 
+
+[section Greatest-width integer types]
+
+The typedef [^intmax_t ]designates a signed integer type capable of representing any value of any signed integer type.
+
+The typedef [^uintmax_t] designates an unsigned integer type capable of representing any value of any unsigned integer type.
+
+These types are provided for all platforms.
+
+[endsect]
+
+[section Integer Constant Macros]
+
+The following macros are always defined after inclusion of this header, these allow
+integer constants of at least the specified width to be declared:  
+INT8_C, UINT8_C, INT16_C, UINT16_C, INT32_C, UINT32_C, INTMAX_C, UINTMAX_C.
+
+The macros INT64_C and UINT64_C are also defined if the the macro BOOST_NO_INT64_T is not defined.
+
+The C99 macro __STDC_CONSTANT_MACROS is also defined as an artifact of the implementation.
+
+For example:
+
+   #include <boost/cstdint.hpp>
+   
+   // Here the constant 0x1FFFFFFFF has the correct suffix applied:
+   static const boost::uint64_t c = INT64_C(0x1FFFFFFFF); 
+
+[endsect]
+
+[endsect]
+
+[section:traits Integer Traits]
+
+[section Motivation]
+
+The C++ Standard Library <limits> header supplies a class template `numeric_limits<>` with specializations for each fundamental type.
+
+For integer types, the interesting members of `std::numeric_limits<>` are: 
+
+   static const bool is_specialized;      // Will be true for integer types.
+   static T min() throw();                // Smallest representable value.
+   static T max() throw();                // Largest representable value.
+   static const int digits;               // For integers, the number of value bits.
+   static const int digits10;             // The number of base 10 digits that can be represented.
+   static const bool is_signed;           // True if the type is signed.
+   static const bool is_integer;          // Will be true for all integer types.
+
+For many uses, these are sufficient. 
+But min() and max() are problematical because they are not constant expressions (std::5.19), 
+yet some usages require constant expressions. 
+
+The template class [^integer_traits] addresses this problem. 
+
+[endsect] 
+
+[section Synopsis]
+
+   namespace boost {
+     template<class T>
+     class integer_traits : public std::numeric_limits<T>
+     {
+     public:
+        static const bool is_integral = false;
+        //
+        // These members are defined only if T is a built-in
+        // integal type:
+        //
+        static const T const_min = ``['implementation-defined]``;
+        static const T const_max = ``['implementation-defined]``;
+     };
+   }
+
+[endsect] 
+
+[section Description]
+
+Template class [^integer_traits] is derived from [^std::numeric_limits]. The primary specialization adds the single 
+[^bool] member [^is_integral] with the compile-time constant value [^false]. 
+However, for all integral types [^T] (std::3.9.1/7 [basic.fundamental]), there are specializations 
+provided with the following compile-time constants defined: 
+
+[table 
+   [[member][type][value]]
+   [[[^is_integral]][bool][[^true]]]
+   [[[^const_min]][[^T]][equivalent to [^std::numeric_limits<T>::min()]]]
+   [[[^const_max]][[^T]][equivalent to [^std::numeric_limits<T>::max()]]]
+]
+
+Note: The /is_integral/ flag is provided, because a user-defined integer class should specialize 
+[^std::numeric_limits<>::is_integer = true], while compile-time constants 
+[^const_min] and [^const_max] are not provided for that user-defined class, unless boost::integer_traits is also specialized. 
+
+[endsect] 
+
+[section Test Program]
+
+The program [^[@../../test/integer_traits_test.cpp integer_traits_test.cpp]] exercises the [^integer_traits] class. 
+
+[endsect] 
+
+[section Acknowledgements]
+
+Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer traits idea on the boost mailing list in August 1999.
+
+[endsect]
+[endsect]
+
+[section:integer Integer Type Selection]
+
+The [@../../../../boost/integer.hpp <boost/integer.hpp>] type selection templates allow 
+integer types to be selected based on desired characteristics such as number of bits or maximum value. 
+This facility is particularly useful for solving generic programming problems.
+
+[section:synopsis Synopsis]
+
+   namespace boost
+   {
+     //  fast integers from least integers
+     template<typename LeastInt>
+     struct int_fast_t
+     {
+         typedef ``['implementation-defined-type]``  type;
+     };
+
+     //  signed
+     template<int Bits>
+     struct int_t 
+     {
+         /* Member exact may or may not be defined depending upon Bits */
+         typedef ``['implementation-defined-type]``  exact;
+         typedef ``['implementation-defined-type]``  least;
+         typedef int_fast_t<least>::fast      fast;
+     };
+
+     //  unsigned
+     template<int Bits>
+     struct uint_t 
+     {
+         /* Member exact may or may not be defined depending upon Bits */
+         typedef ``['implementation-defined-type]``  exact;
+         typedef ``['implementation-defined-type]``  least;
+         typedef int_fast_t<least>::fast      fast;
+     };
+
+     //  signed
+     template<long long MaxValue>
+     struct int_max_value_t 
+     {
+         typedef ``['implementation-defined-type]``  least;
+         typedef int_fast_t<least>::fast      fast;
+     };
+
+     template<long long MinValue>
+     struct int_min_value_t 
+     {
+         typedef ``['implementation-defined-type]``  least;
+         typedef int_fast_t<least>::fast      fast;
+     };
+
+     //  unsigned
+     template<unsigned long long Value>
+     struct uint_value_t 
+     {
+         typedef ``['implementation-defined-type]``  least;
+         typedef int_fast_t<least>::fast      fast;
+     };
+   } // namespace boost
+
+[endsect]
+
+[section:easiest Easiest-to-Manipulate Types]
+
+The [^int_fast_t] class template maps its input type to the next-largest type that the processor 
+can manipulate the easiest, or to itself if the input type is already an easy-to-manipulate type. 
+For instance, processing a bunch of [^char] objects may go faster if they were converted to [^int] objects before processing. 
+The input type, passed as the only template parameter, must be a built-in integral type, except [^bool]. 
+Unsigned integral types can be used, as well as signed integral types. 
+The output type is given as the nested type [^fast].
+
+[*Implementation Notes:] 
+By default, the output type is identical to the input type. Eventually, this code's implementation should 
+be customized for each platform to give accurate mappings between the built-in types and the easiest-to-manipulate 
+built-in types. Also, there is no guarantee that the output type actually is easier to manipulate than the input type.
+
+[endsect]
+
+[section:sized Sized Types]
+
+The [^int_t], [^uint_t], [^int_max_value_t], [^int_min_value_t], and [^uint_value_t] class templates find 
+the most appropiate built-in integral type for the given template parameter. This type is given by the 
+nested type [^least]. The easiest-to-manipulate version of that type is given by the nested type [^fast]. 
+The following table describes each template's criteria.
+
+[table Criteria for the Sized Type Class Templates
+   [
+      [Class Template][Template Parameter Mapping]
+   ]
+   [
+      [[^boost::int_t<N>::least]]
+      [The smallest, built-in, signed integral type with at least /N/ bits, including the sign bit. 
+      The parameter should be a positive number. A compile-time error results if the parameter is 
+      larger than the number of bits in the largest integer type.]
+   ]
+   [
+      [[^boost::int_t<N>::fast]]
+      [The easiest-to-manipulate, built-in, signed integral type with at least /N/ bits, including the sign bit. 
+      The parameter should be a positive number. A compile-time error results if the parameter is 
+      larger than the number of bits in the largest integer type.]
+   ]
+   [
+      [[^boost::int_t<N>::exact]]
+      [A built-in, signed integral type with exactly /N/ bits, including the sign bit. 
+      The parameter should be a positive number.  Note that the member /exact/ is defined
+      [*only] if there exists a type with exactly /N/ bits.]
+   ]
+   [
+      [[^boost::uint_t<N>::least]]
+      [The smallest, built-in, unsigned integral type with at least /N/ bits. 
+      The parameter should be a positive number. A compile-time error results if the 
+      parameter is larger than the number of bits in the largest integer type.]
+   ]
+   [
+      [[^boost::uint_t<N>::fast]]
+      [The easiest-to-manipulate, built-in, unsigned integral type with at least /N/ bits. 
+      The parameter should be a positive number. A compile-time error results if the 
+      parameter is larger than the number of bits in the largest integer type.]
+   ]
+   [
+      [[^boost::uint_t<N>::exact]]
+      [A built-in, unsigned integral type with exactly /N/ bits. 
+      The parameter should be a positive number. A compile-time error results if the 
+      parameter is larger than the number of bits in the largest integer type.  
+      Note that the member /exact/ is defined
+      [*only] if there exists a type with exactly N bits.]
+   ]
+   [
+      [[^boost::int_max_value_t<V>::last]]
+      [The smallest, built-in, signed integral type that can hold all the values in the inclusive range ['0 - V]. 
+      The parameter should be a positive number.]
+   ]
+   [
+      [[^boost::int_max_value_t<V>::fast]]
+      [The easiest-to-manipulate, built-in, signed integral type that can hold all the values in the inclusive range ['0 - V]. 
+      The parameter should be a positive number.]
+   ]
+   [
+      [[^boost::int_min_value_t<V>::least]]
+      [The smallest, built-in, signed integral type that can hold all the values in the inclusive range ['V - 0]. 
+      The parameter should be a negative number.]
+   ]
+   [
+      [[^boost::int_min_value_t<V>::fast]]
+      [The easiest-to-manipulate, built-in, signed integral type that can hold all the values in the inclusive range ['V - 0]. 
+      The parameter should be a negative number.]
+   ]
+   [
+      [[^boost::uint_value_t<V>::least]]
+      [The smallest, built-in, unsigned integral type that can hold all positive values
+      up to and including /V/. The parameter should be a positive number.]
+   ]
+   [
+      [[^boost::uint_value_t<V>::fast]]
+      [The easiest-to-manipulate, built-in, unsigned integral type that can hold all positive values
+      up to and including /V/. The parameter should be a positive number.]
+   ]
+]
+
+[endsect]
+
+[section Example]
+
+   #include <boost/integer.hpp>
+
+   //...
+
+   int main()
+   {
+       boost::int_t<24>::least my_var;  // my_var has at least 24-bits
+       //...
+       // This one is guarenteed not to be truncated:
+       boost::int_max_value_t<1000>::least my1000 = 1000;
+       //...
+       // This one is guarenteed not to be truncated, and as fast
+       // to manipulate as possible, its size may be greater than
+       // that of my1000:
+       boost::int_max_value_t<1000>::fast my_fast1000 = 1000;
+   }
+
+[endsect]
+
+[section Demonstration Program]
+
+The program [@../../test/integer_test.cpp integer_test.cpp] is a simplistic demonstration of the results from instantiating 
+various examples of the sized type class templates.
+
+[endsect]
+
+[section Rationale]
+
+The rationale for the design of the templates in this header includes:
+
+* Avoid recursion because of concern about C++'s limited guaranteed recursion depth (17).
+* Avoid macros on general principles.
+* Try to keep the design as simple as possible.
+
+[endsect]
+
+[section Alternative]
+
+If the number of bits required is known beforehand, it may be more appropriate to use the types supplied 
+in [@../../../../boost/cstdint.hpp <boost/cstdint.hpp>].
+
+[endsect]
+
+[section Credits]
+
+The author of most of the Boost integer type choosing templates is 
+[@http://www.boost.org/people/beman_dawes.html Beman Dawes]. 
+He gives thanks to Valentin Bonnard and [@http://www.boost.org/people/kevlin_henney.htm Kevlin Henney] 
+for sharing their designs for similar templates. 
+[@http://www.boost.org/people/daryle_walker.html Daryle Walker] designed the value-based sized templates.
+
+[endsect]
+[endsect]
+
+
+
+[section:mask Integer Masks]
+
+[section Overview]
+
+The class templates in [@../../../../boost/integer/integer_mask.hpp <boost/integer/integer_mask.hpp>] 
+provide bit masks for a certain bit position or a contiguous-bit pack of a certain size. 
+The types of the masking constants come from the [link boost_integer.integer integer type selection templates] header.
+
+[endsect]
+
+[section Synopsis]
+
+   #include <cstddef>  // for std::size_t
+
+   namespace boost
+   {
+
+   template <std::size_t Bit>
+   struct high_bit_mask_t
+   {
+       typedef ``['implementation-defined-type]``  least;
+       typedef ``['implementation-defined-type]``  fast;
+
+       static const least       high_bit       = ``['implementation-defined]``;
+       static const fast        high_bit_fast  = ``['implementation-defined]``;
+
+       static const std::size_t bit_position   = Bit;
+   };
+
+   template <std::size_t Bits>
+   struct low_bits_mask_t
+   {
+       typedef ``['implementation-defined-type]``  least;
+       typedef ``['implementation-defined-type]``  fast;
+
+       static const least       sig_bits       = ``['implementation-defined]``;
+       static const fast        sig_bits_fast  = ``['implementation-defined]``;
+
+       static const std::size_t bit_count      = Bits;
+   };
+
+   // Specializations for low_bits_mask_t exist for certain bit counts.
+
+   }  // namespace boost
+
+[endsect] 
+
+[section Single Bit-Mask Class Template]
+
+The [^boost::high_bit_mask_t] class template provides constants for bit masks representing the bit at a 
+certain position. The masks are equivalent to the value 2[super Bit], where [^Bit] is the template parameter. 
+The bit position must be a nonnegative number from zero to ['Max], where Max is one less than the 
+number of bits supported by the largest unsigned built-in integral type. The following table describes 
+the members of an instantiation of [^high_bit_mask_t].
+
+[table Members of the `boost::high_bit_mask_t` Class Template
+   [[Member][Meaning]]
+   [[[^least]][The smallest, unsigned, built-in type that supports the given bit position.]]
+   [[[^fast]][The easiest-to-manipulate analog of [^least].]]
+   [[[^high_bit]][A [^least] constant of the value 2[super Bit].]]
+   [[[^high_bit_fast]][A [^fast] analog of [^high_bit].]]
+   [[[^bit_position]][The value of the template parameter, in case its needed from a renamed instantiation of the class template.]]
+]
+
+[endsect] 
+
+[section Group Bit-Mask Class Template]
+
+The [^boost::low_bits_mask_t] class template provides constants for bit masks 
+equivalent to the value (2[super Bits] - 1), where [^Bits] is the template parameter. 
+The parameter [^Bits] must be a non-negative integer from 
+zero to ['Max], where Max is the number of bits supported by the largest, unsigned, built-in integral type. 
+The following table describes the members of [^low_bits_mask_t].
+
+[table Members of the [^boost::low_bits_mask_t] Class Template
+[[Member][Meaning]]
+[[[^least]][The smallest, unsigned built-in type that supports the given bit count.]]
+[[[^fast]][The easiest-to-manipulate analog of [^least].]]
+[[[^sig_bits]][A [^least] constant of the desired bit-masking value.]]
+[[[^sig_bits_fast]][A [^fast] analog of [^sig_bits].]]
+[[[^bit_count]][The value of the template parameter, in case its needed from a renamed instantiation of the class template.]]
+]
+
+[endsect]
+
+[section Implementation Notes]
+
+When [^Bits] is the exact size of a built-in unsigned type, the implementation has to change to 
+prevent undefined behavior. Therefore, there are specializations of [^low_bits_mask_t] at those bit counts.
+
+[endsect]
+
+[section Example]
+
+   #include <boost/integer/integer_mask.hpp>
+
+   //...
+
+   int main()
+   {
+       typedef boost::high_bit_mask_t<29>  mask1_type;
+       typedef boost::low_bits_mask_t<15>  mask2_type;
+
+       mask1_type::least  my_var1;
+       mask2_type::fast   my_var2;
+       //...
+
+       my_var1 |= mask1_type::high_bit;
+       my_var2 &= mask2_type::sig_bits_fast;
+
+       //...
+   }
+
+[endsect] 
+
+[section Demonstration Program]
+
+The program [@../../test/integer_mask_test.cpp integer_mask_test.cpp] is a simplistic demonstration of the 
+results from instantiating various examples of the bit mask class templates.
+
+[endsect] 
+
+[section Rationale]
+
+The class templates in this header are an extension of the [link boost_integer.integer integer type selection class templates]. 
+The new class templates provide the same sized types, but also convenient masks to use when extracting the 
+highest or all the significant bits when the containing built-in type contains more bits. 
+This prevents contamination of values by the higher, unused bits.
+
+[endsect] 
+
+[section Credits]
+
+The author of the Boost bit mask class templates is [@http://www.boost.org/people/daryle_walker.html Daryle Walker].
+
+[endsect]
+[endsect]
+
+[section:log2 Compile Time log2 Calculation]
+
+The class template in [@../../../../boost/integer/static_log2.hpp <boost/integer/static_log2.hpp>] 
+determines the position of the highest bit in a given value. This facility is useful for solving generic programming problems.
+
+[section Synopsis]
+
+   namespace boost
+   {
+
+     typedef ``['implementation-defined]`` static_log2_argument_type;
+     typedef ``['implementation-defined]`` static_log2_result_type;
+
+     template <static_log2_argument_type arg>
+     struct static_log2
+     {
+       static const static_log2_result_type value = ``['implementation-defined]``;
+     };
+
+
+     template < >
+     struct static_log2< 0 >
+     {
+       // The logarithm of zero is undefined.
+     };
+
+
+   }  // namespace boost
+
+[endsect] 
+
+[section Usage]
+
+The [^boost::static_log2] class template takes one template parameter, a value of type 
+[^static_log2_argument_type]. The template only defines one member, [^value], which gives the 
+truncated, base-two logarithm of the template argument.
+
+Since the logarithm of zero, for any base, is undefined, there is a specialization of [^static_log2] 
+for a template argument of zero. This specialization has no members, so an attempt to use the base-two 
+logarithm of zero results in a compile-time error.
+
+Note: 
+
+* [^static_log2_argument_type] is an ['unsigned integer type] (C++ standard, 3.9.1p3).
+* [^static_log2_result_type] is an ['integer type] (C++ standard, 3.9.1p7).
+
+[endsect] 
+
+[section Demonstration Program]
+
+The program [@../../test/static_log2_test.cpp static_log2_test.cpp] is a simplistic 
+demonstration of the results from instantiating various examples of the binary logarithm class template.
+
+[endsect]
+
+[section Rationale]
+
+The base-two (binary) logarithm, abbreviated lb, function is occasionally used to give order-estimates 
+of computer algorithms. The truncated logarithm can be considered the highest power-of-two in a value, 
+which corresponds to the value's highest set bit (for binary integers). Sometimes the highest-bit position 
+could be used in generic programming, which requires the position to be available statically (['i.e.] at compile-time).
+
+[endsect] 
+
+[section Credits]
+
+The original version of the Boost binary logarithm class template was 
+written by [@http://www.boost.org/people/daryle_walker.html Daryle Walker] and then 
+enhanced by Giovanni Bajo with support for compilers without partial template specialization. 
+The current version was suggested, together with a reference implementation, by Vesa Karvonen. 
+Gennaro Prota wrote the actual source file.
+
+[endsect]
+[endsect]
+
+[section:minmax Compile time min/max calculation]
+
+The class templates in [@../../../../boost/integer/static_min_max.hpp <boost/integer/static_min_max.hpp>] 
+provide a compile-time evaluation of the minimum or maximum of two integers. These facilities are useful 
+for generic programming problems.
+
+[section Synopsis]
+
+   namespace boost
+   {
+   
+   typedef ``['implementation-defined]`` static_min_max_signed_type;
+   typedef ``['implementation-defined]`` static_min_max_unsigned_type;
+
+   template <static_min_max_signed_type Value1, static_min_max_signed_type Value2 >
+       struct static_signed_min;
+
+   template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+       struct static_signed_max;
+
+   template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+       struct static_unsigned_min;
+
+   template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+       struct static_unsigned_max;
+
+   }
+
+[endsect] 
+
+[section Usage]
+
+The four class templates provide the combinations for finding the minimum or maximum of two [^signed] or 
+[^unsigned] ([^long]) parameters, /Value1/ and /Value2/, at compile-time. Each template has a single static data member, 
+[^value], which is set to the respective minimum or maximum of the template's parameters.
+
+[endsect] 
+
+[section Example]
+
+   #include <boost/integer/static_min_max.hpp>
+
+   template < unsigned long AddendSize1, unsigned long AddendSize2 >
+   class adder
+   {
+   public:
+       static  unsigned long  const  addend1_size = AddendSize1;
+       static  unsigned long  const  addend2_size = AddendSize2;
+       static  unsigned long  const  sum_size = boost::static_unsigned_max<AddendSize1, AddendSize2>::value + 1;
+
+       typedef int  addend1_type[ addend1_size ];
+       typedef int  addend2_type[ addend2_size ];
+       typedef int  sum_type[ sum_size ];
+
+       void  operator ()( addend1_type const &a1, addend2_type const &a2, sum_type &s ) const;
+   };
+
+   //...
+
+   int main()
+   {
+       int const   a1[] = { 0, 4, 3 };  // 340
+       int const   a2[] = { 9, 8 };     //  89
+       int         s[ 4 ];
+       adder<3,2>  obj;
+
+       obj( a1, a2, s );  // 's' should be 429 or { 9, 2, 4, 0 }
+       //...
+   }
+
+[endsect]
+
+[section Demonstration Program]
+
+The program [@../../test/static_min_max_test.cpp static_min_max_test.cpp] is a simplistic demonstration of 
+various comparisons using the compile-time extrema class templates.
+
+[endsect] 
+
+[section Rationale]
+
+Sometimes the minimum or maximum of several values needs to be found for later compile-time processing, 
+['e.g.] for a bound for another class template.
+
+[endsect]
+
+[section Credits]
+
+The author of the Boost compile-time extrema class templates is [@http://www.boost.org/people/daryle_walker.html Daryle Walker].
+
+[endsect]
+[endsect]
+
+[section:history History]
+
+[h4 1.42.0]
+
+* Reverted Trunk to release branch state (i.e. a "known good state").
+* Fixed issues: [@https://svn.boost.org/trac/boost/ticket/653 653], 
+[@https://svn.boost.org/trac/boost/ticket/3084 3084], 
+[@https://svn.boost.org/trac/boost/ticket/3177 3177], 
+[@https://svn.boost.org/trac/boost/ticket/3180 3180], 
+[@https://svn.boost.org/trac/boost/ticket/3548 3568], 
+[@https://svn.boost.org/trac/boost/ticket/3657 3657], 
+[@https://svn.boost.org/trac/boost/ticket/2134 2134].
+* Added long long support to [^boost::static_log2], [^boost::static_signed_min], [^boost::static_signed_max], 
+[^boost::static_unsigned_min][^boost::static_unsigned_max], when available.
+* The argument type and the result type of [^boost::static_signed_min] etc are now typedef'd. 
+Formerly, they were hardcoded as [^unsigned long] and [^int] respectively. Please, use the 
+provided typedefs in new code (and update old code as soon as possible).
+
+[h4 1.32.0]
+
+* The argument type and the result type of [^boost::static_log2] are now typedef'd. 
+Formerly, they were hardcoded as [^unsigned long] and [^int] respectively. Please, use the 
+provided typedefs in new code (and update old code as soon as possible).
+
+[endsect]
+

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/Jamfile.v2	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,25 @@
+#~ Copyright Rene Rivera 2008
+#~ Distributed under the Boost Software License, Version 1.0.
+#~ (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+import testing ;
+
+project : requirements <warnings>all <toolset>gcc:<cxxflags>-Wextra ;
+
+test-suite integer
+    : 
+        [ run cstdint_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long ]
+        [ run cstdint_test2.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long ]
+        [ run integer_traits_test.cpp ]
+        [ run integer_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long <toolset>sun:<cxxflags>"-Qoption ccfe -tmpldepth=128" ]
+        [ run integer_mask_test.cpp ]
+        [ run static_log2_test.cpp ]
+        [ run static_min_max_test.cpp ]
+        [ compile cstdint_include_test.cpp ]
+        [ compile integer_traits_include_test.cpp ]
+        [ compile integer_include_test.cpp ]
+        [ compile integer_mask_include_test.cpp ]
+        [ compile static_log2_include_test.cpp ]
+        [ compile static_min_max_include_test.cpp ]
+        [ compile integer_fwd_include_test.cpp ]
+    ;

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/cstdint_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/cstdint_include_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,69 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define __STDC_CONSTANT_MACROS
+#include <boost/cstdint.hpp> // must be the only #include!
+
+int main()
+{
+   boost::int8_t i8 = INT8_C(0);
+   (void)i8;
+   boost::uint8_t ui8 = UINT8_C(0);
+   (void)ui8;
+   boost::int16_t i16 = INT16_C(0);
+   (void)i16;
+   boost::uint16_t ui16 = UINT16_C(0);
+   (void)ui16;
+   boost::int32_t i32 = INT32_C(0);
+   (void)i32;
+   boost::uint32_t ui32 = UINT32_C(0);
+   (void)ui32;
+#ifndef BOOST_NO_INT64_T
+   boost::int64_t i64 = 0;
+   (void)i64;
+   boost::uint64_t ui64 = 0;
+   (void)ui64;
+#endif
+   boost::int_least8_t i8least = INT8_C(0);
+   (void)i8least;
+   boost::uint_least8_t ui8least = UINT8_C(0);
+   (void)ui8least;
+   boost::int_least16_t i16least = INT16_C(0);
+   (void)i16least;
+   boost::uint_least16_t ui16least = UINT16_C(0);
+   (void)ui16least;
+   boost::int_least32_t i32least = INT32_C(0);
+   (void)i32least;
+   boost::uint_least32_t ui32least = UINT32_C(0);
+   (void)ui32least;
+#ifndef BOOST_NO_INT64_T
+   boost::int_least64_t i64least = 0;
+   (void)i64least;
+   boost::uint_least64_t ui64least = 0;
+   (void)ui64least;
+#endif
+   boost::int_fast8_t i8fast = INT8_C(0);
+   (void)i8fast;
+   boost::uint_fast8_t ui8fast = UINT8_C(0);
+   (void)ui8fast;
+   boost::int_fast16_t i16fast = INT16_C(0);
+   (void)i16fast;
+   boost::uint_fast16_t ui16fast = UINT16_C(0);
+   (void)ui16fast;
+   boost::int_fast32_t i32fast = INT32_C(0);
+   (void)i32fast;
+   boost::uint_fast32_t ui32fast = UINT32_C(0);
+   (void)ui32fast;
+#ifndef BOOST_NO_INT64_T
+   boost::int_fast64_t i64fast = 0;
+   (void)i64fast;
+   boost::uint_fast64_t ui64fast = 0;
+   (void)ui64fast;
+#endif
+   boost::intmax_t im = 0;
+   (void)im;
+   boost::uintmax_t uim = 0;
+   (void)uim;
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/cstdint_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/cstdint_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,238 @@
+//  boost cstdint.hpp test program  ------------------------------------------//
+
+//  Copyright Beman Dawes 2000.  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//  See http://www.boost.org/libs/integer for documentation.
+
+//  Revision History
+//   11 Sep 01  Adapted to work with macros defined in native stdint.h (John Maddock)
+//   12 Nov 00  Adapted to merged <boost/cstdint.hpp>
+//   23 Sep 00  Added INTXX_C constant macro support + int64_t support (John Maddock).
+//   28 Jun 00  Initial version
+
+//
+// There are two ways to test this: in version 1, we include cstdint.hpp as the first
+// include, which means we get decide whether __STDC_CONSTANT_MACROS is defined.
+// In version two we include stdint.h with __STDC_CONSTANT_MACROS *NOT* defined first,
+// and check that we still end up with compatible definitions for the INT#_C macros.
+//
+// This is version 1.
+//
+
+#if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))
+// We can't suppress this warning on the command line as not all GCC versions support -Wno-type-limits :
+#pragma GCC diagnostic ignored "-Wtype-limits"
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <iostream>
+
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+//
+// the following class is designed to verify
+// that the various INTXX_C macros can be used
+// in integral constant expressions:
+//
+struct integral_constant_checker
+{
+  static const boost::int8_t          int8          = INT8_C(-127);
+  static const boost::int_least8_t    int_least8    = INT8_C(-127);
+  static const boost::int_fast8_t     int_fast8     = INT8_C(-127);
+
+  static const boost::uint8_t         uint8         = UINT8_C(255);
+  static const boost::uint_least8_t   uint_least8   = UINT8_C(255);
+  static const boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
+
+  static const boost::int16_t         int16         = INT16_C(-32767);
+  static const boost::int_least16_t   int_least16   = INT16_C(-32767);
+  static const boost::int_fast16_t    int_fast16    = INT16_C(-32767);
+
+  static const boost::uint16_t        uint16         = UINT16_C(65535);
+  static const boost::uint_least16_t  uint_least16   = UINT16_C(65535);
+  static const boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
+
+  static const boost::int32_t         int32         = INT32_C(-2147483647);
+  static const boost::int_least32_t   int_least32   = INT32_C(-2147483647);
+  static const boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
+
+  static const boost::uint32_t        uint32        = UINT32_C(4294967295);
+  static const boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
+  static const boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
+
+  static void check();
+};
+
+void integral_constant_checker::check()
+{
+  BOOST_TEST( int8 == -127 );
+  BOOST_TEST( int_least8 == -127 );
+  BOOST_TEST( int_fast8 == -127 );
+  BOOST_TEST( uint8 == 255u );
+  BOOST_TEST( uint_least8 == 255u );
+  BOOST_TEST( uint_fast8 == 255u );
+  BOOST_TEST( int16 == -32767 );
+  BOOST_TEST( int_least16 == -32767 );
+  BOOST_TEST( int_fast16 == -32767 );
+  BOOST_TEST( uint16 == 65535u );
+  BOOST_TEST( uint_least16 == 65535u );
+  BOOST_TEST( uint_fast16 == 65535u );
+  BOOST_TEST( int32 == -2147483647 );
+  BOOST_TEST( int_least32 == -2147483647 );
+  BOOST_TEST( int_fast32 == -2147483647 );
+  BOOST_TEST( uint32 == 4294967295u );
+  BOOST_TEST( uint_least32 == 4294967295u );
+  BOOST_TEST( uint_fast32 == 4294967295u );
+}
+#endif // BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+
+//
+// the following function simply verifies that the type
+// of an integral constant is correctly defined:
+//
+#ifdef __BORLANDC__
+#pragma option -w-8008
+#pragma option -w-8066
+#endif
+template <class T1, class T2>
+void integral_constant_type_check(T1, T2)
+{
+   //
+   // the types T1 and T2 may not be exactly
+   // the same type, but they should be the
+   // same size and signedness. We could use
+   // numeric_limits to verify this, but
+   // numeric_limits implementations currently
+   // vary too much, or are incomplete or missing.
+   //
+   T1 t1 = static_cast<T1>(-1);  // cast suppresses warnings
+   T2 t2 = static_cast<T2>(-1);  // ditto
+#if defined(BOOST_HAS_STDINT_H)
+   // if we have a native stdint.h
+   // then the INTXX_C macros may define
+   // a type that's wider than required:
+   BOOST_TEST(sizeof(T1) <= sizeof(T2));
+#else
+   BOOST_TEST(sizeof(T1) == sizeof(T2));
+   BOOST_TEST(t1 == t2);
+#endif
+#if defined(BOOST_HAS_STDINT_H)
+   // native headers are permitted to promote small
+   // unsigned types to type int:
+   if(sizeof(T1) >= sizeof(int))
+   {
+      if(t1 > 0)
+        BOOST_TEST(t2 > 0);
+      else
+        BOOST_TEST(!(t2 > 0));
+   }
+   else if(t1 < 0)
+      BOOST_TEST(!(t2 > 0));
+#else
+   if(t1 > 0)
+     BOOST_TEST(t2 > 0);
+   else
+     BOOST_TEST(!(t2 > 0));
+#endif
+}
+
+
+int main(int, char*[])
+{
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+  integral_constant_checker::check();
+#endif
+  //
+  // verify the types of the integral constants:
+  //
+  integral_constant_type_check(boost::int8_t(0), INT8_C(0));
+  integral_constant_type_check(boost::uint8_t(0), UINT8_C(0));
+  integral_constant_type_check(boost::int16_t(0), INT16_C(0));
+  integral_constant_type_check(boost::uint16_t(0), UINT16_C(0));
+  integral_constant_type_check(boost::int32_t(0), INT32_C(0));
+  integral_constant_type_check(boost::uint32_t(0), UINT32_C(0));
+#ifndef BOOST_NO_INT64_T
+  integral_constant_type_check(boost::int64_t(0), INT64_C(0));
+  integral_constant_type_check(boost::uint64_t(0), UINT64_C(0));
+#endif
+  //
+  boost::int8_t          int8          = INT8_C(-127);
+  boost::int_least8_t    int_least8    = INT8_C(-127);
+  boost::int_fast8_t     int_fast8     = INT8_C(-127);
+
+  boost::uint8_t         uint8         = UINT8_C(255);
+  boost::uint_least8_t   uint_least8   = UINT8_C(255);
+  boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
+
+  boost::int16_t         int16         = INT16_C(-32767);
+  boost::int_least16_t   int_least16   = INT16_C(-32767);
+  boost::int_fast16_t    int_fast16    = INT16_C(-32767);
+
+  boost::uint16_t        uint16         = UINT16_C(65535);
+  boost::uint_least16_t  uint_least16   = UINT16_C(65535);
+  boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
+
+  boost::int32_t         int32         = INT32_C(-2147483647);
+  boost::int_least32_t   int_least32   = INT32_C(-2147483647);
+  boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
+
+  boost::uint32_t        uint32        = UINT32_C(4294967295);
+  boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
+  boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
+
+#ifndef BOOST_NO_INT64_T
+  boost::int64_t         int64         = INT64_C(-9223372036854775807);
+  boost::int_least64_t   int_least64   = INT64_C(-9223372036854775807);
+  boost::int_fast64_t    int_fast64    = INT64_C(-9223372036854775807);
+
+  boost::uint64_t        uint64        = UINT64_C(18446744073709551615);
+  boost::uint_least64_t  uint_least64  = UINT64_C(18446744073709551615);
+  boost::uint_fast64_t   uint_fast64   = UINT64_C(18446744073709551615);
+
+  boost::intmax_t        intmax        = INTMAX_C(-9223372036854775807);
+  boost::uintmax_t       uintmax       = UINTMAX_C(18446744073709551615);
+#else
+  boost::intmax_t        intmax        = INTMAX_C(-2147483647);
+  boost::uintmax_t       uintmax       = UINTMAX_C(4294967295);
+#endif
+
+  BOOST_TEST( int8 == -127 );
+  BOOST_TEST( int_least8 == -127 );
+  BOOST_TEST( int_fast8 == -127 );
+  BOOST_TEST( uint8 == 255u );
+  BOOST_TEST( uint_least8 == 255u );
+  BOOST_TEST( uint_fast8 == 255u );
+  BOOST_TEST( int16 == -32767 );
+  BOOST_TEST( int_least16 == -32767 );
+  BOOST_TEST( int_fast16 == -32767 );
+  BOOST_TEST( uint16 == 65535u );
+  BOOST_TEST( uint_least16 == 65535u );
+  BOOST_TEST( uint_fast16 == 65535u );
+  BOOST_TEST( int32 == -2147483647 );
+  BOOST_TEST( int_least32 == -2147483647 );
+  BOOST_TEST( int_fast32 == -2147483647 );
+  BOOST_TEST( uint32 == 4294967295u );
+  BOOST_TEST( uint_least32 == 4294967295u );
+  BOOST_TEST( uint_fast32 == 4294967295u );
+
+#ifndef BOOST_NO_INT64_T
+  BOOST_TEST( int64 == INT64_C(-9223372036854775807) );
+  BOOST_TEST( int_least64 == INT64_C(-9223372036854775807) );
+  BOOST_TEST( int_fast64 == INT64_C(-9223372036854775807) );
+  BOOST_TEST( uint64 == UINT64_C(18446744073709551615) );
+  BOOST_TEST( uint_least64 == UINT64_C(18446744073709551615) );
+  BOOST_TEST( uint_fast64 == UINT64_C(18446744073709551615) );
+  BOOST_TEST( intmax == INT64_C(-9223372036854775807) );
+  BOOST_TEST( uintmax == UINT64_C(18446744073709551615) );
+#else
+  BOOST_TEST( intmax == -2147483647 );
+  BOOST_TEST( uintmax == 4294967295u );
+#endif
+
+
+  std::cout << "OK\n";
+  return boost::report_errors();
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/cstdint_test2.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/cstdint_test2.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,248 @@
+//  boost cstdint.hpp test program  ------------------------------------------//
+
+//  Copyright Beman Dawes 2000.  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//  See http://www.boost.org/libs/integer for documentation.
+
+//  Revision History
+//   11 Sep 01  Adapted to work with macros defined in native stdint.h (John Maddock)
+//   12 Nov 00  Adapted to merged <boost/cstdint.hpp>
+//   23 Sep 00  Added INTXX_C constant macro support + int64_t support (John Maddock).
+//   28 Jun 00  Initial version
+
+//
+// There are two ways to test this: in version 1, we include cstdint.hpp as the first
+// include, which means we get decide whether __STDC_CONSTANT_MACROS is defined.
+// In version two we include stdint.h with __STDC_CONSTANT_MACROS *NOT* defined first,
+// and check that we still end up with compatible definitions for the INT#_C macros.
+//
+// This is version 2.
+//
+
+#if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))
+// We can't suppress this warning on the command line as not all GCC versions support -Wno-type-limits :
+#pragma GCC diagnostic ignored "-Wtype-limits"
+#endif
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_STDINT_H
+#ifdef __hpux
+#  include <inttypes.h>
+#else
+#  include <stdint.h>
+#endif
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <iostream>
+
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+//
+// the following class is designed to verify
+// that the various INTXX_C macros can be used
+// in integral constant expressions:
+//
+struct integral_constant_checker
+{
+  static const boost::int8_t          int8          = INT8_C(-127);
+  static const boost::int_least8_t    int_least8    = INT8_C(-127);
+  static const boost::int_fast8_t     int_fast8     = INT8_C(-127);
+
+  static const boost::uint8_t         uint8         = UINT8_C(255);
+  static const boost::uint_least8_t   uint_least8   = UINT8_C(255);
+  static const boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
+
+  static const boost::int16_t         int16         = INT16_C(-32767);
+  static const boost::int_least16_t   int_least16   = INT16_C(-32767);
+  static const boost::int_fast16_t    int_fast16    = INT16_C(-32767);
+
+  static const boost::uint16_t        uint16         = UINT16_C(65535);
+  static const boost::uint_least16_t  uint_least16   = UINT16_C(65535);
+  static const boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
+
+  static const boost::int32_t         int32         = INT32_C(-2147483647);
+  static const boost::int_least32_t   int_least32   = INT32_C(-2147483647);
+  static const boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
+
+  static const boost::uint32_t        uint32        = UINT32_C(4294967295);
+  static const boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
+  static const boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
+
+  static void check();
+};
+
+void integral_constant_checker::check()
+{
+  BOOST_TEST( int8 == -127 );
+  BOOST_TEST( int_least8 == -127 );
+  BOOST_TEST( int_fast8 == -127 );
+  BOOST_TEST( uint8 == 255u );
+  BOOST_TEST( uint_least8 == 255u );
+  BOOST_TEST( uint_fast8 == 255u );
+  BOOST_TEST( int16 == -32767 );
+  BOOST_TEST( int_least16 == -32767 );
+  BOOST_TEST( int_fast16 == -32767 );
+  BOOST_TEST( uint16 == 65535u );
+  BOOST_TEST( uint_least16 == 65535u );
+  BOOST_TEST( uint_fast16 == 65535u );
+  BOOST_TEST( int32 == -2147483647 );
+  BOOST_TEST( int_least32 == -2147483647 );
+  BOOST_TEST( int_fast32 == -2147483647 );
+  BOOST_TEST( uint32 == 4294967295u );
+  BOOST_TEST( uint_least32 == 4294967295u );
+  BOOST_TEST( uint_fast32 == 4294967295u );
+}
+#endif // BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+
+//
+// the following function simply verifies that the type
+// of an integral constant is correctly defined:
+//
+#ifdef __BORLANDC__
+#pragma option -w-8008
+#pragma option -w-8066
+#endif
+template <class T1, class T2>
+void integral_constant_type_check(T1, T2)
+{
+   //
+   // the types T1 and T2 may not be exactly
+   // the same type, but they should be the
+   // same size and signedness. We could use
+   // numeric_limits to verify this, but
+   // numeric_limits implementations currently
+   // vary too much, or are incomplete or missing.
+   //
+   T1 t1 = static_cast<T1>(-1);  // cast suppresses warnings
+   T2 t2 = static_cast<T2>(-1);  // ditto
+#if defined(BOOST_HAS_STDINT_H)
+   // if we have a native stdint.h
+   // then the INTXX_C macros may define
+   // a type that's wider than required:
+   BOOST_TEST(sizeof(T1) <= sizeof(T2));
+#else
+   BOOST_TEST(sizeof(T1) == sizeof(T2));
+   BOOST_TEST(t1 == t2);
+#endif
+#if defined(BOOST_HAS_STDINT_H)
+   // native headers are permitted to promote small
+   // unsigned types to type int:
+   if(sizeof(T1) >= sizeof(int))
+   {
+      if(t1 > 0)
+        BOOST_TEST(t2 > 0);
+      else
+        BOOST_TEST(!(t2 > 0));
+   }
+   else if(t1 < 0)
+      BOOST_TEST(!(t2 > 0));
+#else
+   if(t1 > 0)
+     BOOST_TEST(t2 > 0);
+   else
+     BOOST_TEST(!(t2 > 0));
+#endif
+}
+
+
+int main(int, char*[])
+{
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+  integral_constant_checker::check();
+#endif
+  //
+  // verify the types of the integral constants:
+  //
+  integral_constant_type_check(boost::int8_t(0), INT8_C(0));
+  integral_constant_type_check(boost::uint8_t(0), UINT8_C(0));
+  integral_constant_type_check(boost::int16_t(0), INT16_C(0));
+  integral_constant_type_check(boost::uint16_t(0), UINT16_C(0));
+  integral_constant_type_check(boost::int32_t(0), INT32_C(0));
+  integral_constant_type_check(boost::uint32_t(0), UINT32_C(0));
+#ifndef BOOST_NO_INT64_T
+  integral_constant_type_check(boost::int64_t(0), INT64_C(0));
+  integral_constant_type_check(boost::uint64_t(0), UINT64_C(0));
+#endif
+  //
+  boost::int8_t          int8          = INT8_C(-127);
+  boost::int_least8_t    int_least8    = INT8_C(-127);
+  boost::int_fast8_t     int_fast8     = INT8_C(-127);
+
+  boost::uint8_t         uint8         = UINT8_C(255);
+  boost::uint_least8_t   uint_least8   = UINT8_C(255);
+  boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
+
+  boost::int16_t         int16         = INT16_C(-32767);
+  boost::int_least16_t   int_least16   = INT16_C(-32767);
+  boost::int_fast16_t    int_fast16    = INT16_C(-32767);
+
+  boost::uint16_t        uint16         = UINT16_C(65535);
+  boost::uint_least16_t  uint_least16   = UINT16_C(65535);
+  boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
+
+  boost::int32_t         int32         = INT32_C(-2147483647);
+  boost::int_least32_t   int_least32   = INT32_C(-2147483647);
+  boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
+
+  boost::uint32_t        uint32        = UINT32_C(4294967295);
+  boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
+  boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
+
+#ifndef BOOST_NO_INT64_T
+  boost::int64_t         int64         = INT64_C(-9223372036854775807);
+  boost::int_least64_t   int_least64   = INT64_C(-9223372036854775807);
+  boost::int_fast64_t    int_fast64    = INT64_C(-9223372036854775807);
+
+  boost::uint64_t        uint64        = UINT64_C(18446744073709551615);
+  boost::uint_least64_t  uint_least64  = UINT64_C(18446744073709551615);
+  boost::uint_fast64_t   uint_fast64   = UINT64_C(18446744073709551615);
+
+  boost::intmax_t        intmax        = INTMAX_C(-9223372036854775807);
+  boost::uintmax_t       uintmax       = UINTMAX_C(18446744073709551615);
+#else
+  boost::intmax_t        intmax        = INTMAX_C(-2147483647);
+  boost::uintmax_t       uintmax       = UINTMAX_C(4294967295);
+#endif
+
+  BOOST_TEST( int8 == -127 );
+  BOOST_TEST( int_least8 == -127 );
+  BOOST_TEST( int_fast8 == -127 );
+  BOOST_TEST( uint8 == 255u );
+  BOOST_TEST( uint_least8 == 255u );
+  BOOST_TEST( uint_fast8 == 255u );
+  BOOST_TEST( int16 == -32767 );
+  BOOST_TEST( int_least16 == -32767 );
+  BOOST_TEST( int_fast16 == -32767 );
+  BOOST_TEST( uint16 == 65535u );
+  BOOST_TEST( uint_least16 == 65535u );
+  BOOST_TEST( uint_fast16 == 65535u );
+  BOOST_TEST( int32 == -2147483647 );
+  BOOST_TEST( int_least32 == -2147483647 );
+  BOOST_TEST( int_fast32 == -2147483647 );
+  BOOST_TEST( uint32 == 4294967295u );
+  BOOST_TEST( uint_least32 == 4294967295u );
+  BOOST_TEST( uint_fast32 == 4294967295u );
+
+#ifndef BOOST_NO_INT64_T
+  BOOST_TEST( int64 == INT64_C(-9223372036854775807) );
+  BOOST_TEST( int_least64 == INT64_C(-9223372036854775807) );
+  BOOST_TEST( int_fast64 == INT64_C(-9223372036854775807) );
+  BOOST_TEST( uint64 == UINT64_C(18446744073709551615) );
+  BOOST_TEST( uint_least64 == UINT64_C(18446744073709551615) );
+  BOOST_TEST( uint_fast64 == UINT64_C(18446744073709551615) );
+  BOOST_TEST( intmax == INT64_C(-9223372036854775807) );
+  BOOST_TEST( uintmax == UINT64_C(18446744073709551615) );
+#else
+  BOOST_TEST( intmax == -2147483647 );
+  BOOST_TEST( uintmax == 4294967295u );
+#endif
+
+
+  std::cout << "OK\n";
+  return boost::report_errors();
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_fwd_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_fwd_include_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,22 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer_fwd.hpp> // must be the only #include!
+
+// just declare some functions that use the incomplete types in the header:
+
+void f1(const boost::integer_traits<char>*);
+void f2(const boost::int_fast_t<char>*);
+void f3(const boost::int_t<12>*);
+void f4(const boost::uint_t<31>*);
+void f5(const boost::int_max_value_t<100>*);
+void f6(const boost::int_min_value_t<-100>*);
+void f7(const boost::uint_value_t<100>*);
+void f8(const boost::high_bit_mask_t<10>*);
+void f9(const boost::low_bits_mask_t<10>*);
+void f10(boost::static_log2_argument_type, boost::static_log2_result_type, boost::static_log2<10>*);
+void f11(boost::static_min_max_signed_type, boost::static_min_max_unsigned_type);
+void f12(boost::static_signed_min<1, 2>*, boost::static_signed_max<1,2>*);
+void f13(boost::static_unsigned_min<1,2>*, boost::static_unsigned_min<1,2>*);

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_include_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,36 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp> // must be the only #include!
+
+int main()
+{
+   boost::int_fast_t<char>::fast f = 0;
+   (void)f;
+   boost::int_t<16>::fast f2 = 0;
+   (void)f2;
+   boost::int_t<32>::exact e = 0;
+   (void)e;
+   boost::int_t<12>::least l = 0;
+   (void)l;
+   boost::uint_t<16>::fast uf2 = 0;
+   (void)uf2;
+   boost::uint_t<32>::exact ue = 0;
+   (void)ue;
+   boost::uint_t<12>::least ul = 0;
+   (void)ul;
+   boost::int_max_value_t<200>::fast v1 = 0;
+   (void)v1;
+   boost::int_max_value_t<2000>::least v2 = 0;
+   (void)v2;
+   boost::int_min_value_t<-200>::fast v3 = 0;
+   (void)v3;
+   boost::int_min_value_t<-2000>::least v4 = 0;
+   (void)v4;
+   boost::uint_value_t<200>::fast v5 = 0;
+   (void)v5;
+   boost::uint_value_t<2000>::least v6 = 0;
+   (void)v6;
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_mask_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_mask_include_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,18 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer/integer_mask.hpp> // must be the only #include!
+
+int main()
+{
+   boost::high_bit_mask_t<20>::least l = boost::high_bit_mask_t<20>::high_bit;
+   boost::high_bit_mask_t<12>::fast f = boost::high_bit_mask_t<12>::high_bit_fast;
+   l += f + boost::high_bit_mask_t<12>::bit_position;
+   (void)l;
+   boost::low_bits_mask_t<20>::least l2 = boost::low_bits_mask_t<20>::sig_bits;
+   boost::low_bits_mask_t<12>::fast f2 = boost::low_bits_mask_t<12>::sig_bits_fast;
+   l2 += f2 + boost::low_bits_mask_t<12>::bit_count;
+   (void)l2;
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_mask_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_mask_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,123 @@
+//  boost integer_mask.hpp test program  -------------------------------------//
+
+//  (C) Copyright Daryle Walker 2001.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  23 Sep 2001  Initial version (Daryle Walker)
+
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/cstdlib.hpp>               // for boost::exit_success
+#include <boost/integer/integer_mask.hpp>  // for boost::high_bit_mask_t, etc.
+
+#include <iostream>  // for std::cout (std::endl indirectly)
+
+#ifdef BOOST_MSVC
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
+
+#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)  \
+   do{ \
+      unsigned long mask = 0;\
+      if(v > 0)\
+         { mask = ((1ul << (v-1)) - 1); mask <<= 1; mask |= 1; }\
+      BOOST_TEST( ::boost::low_bits_mask_t< (v) >::sig_bits ==  mask); \
+   }while(false);
+#define PRIVATE_LOW_BITS_FAST_TEST(v)  \
+   do{ \
+      unsigned long mask = 0;\
+      if(v > 0)\
+         { mask = ((1ul << (v-1)) - 1); mask <<= 1; mask |= 1; }\
+      BOOST_TEST( ::boost::low_bits_mask_t< (v) >::sig_bits_fast == mask);\
+   }while(false);
+#define PRIVATE_LOW_BITS_TEST(v)  do { PRIVATE_LOW_BITS_SLOW_TEST(v); \
+ PRIVATE_LOW_BITS_FAST_TEST(v); } while (false)
+
+
+int main( int, char*[] )
+{
+    using std::cout;
+    using std::endl;
+
+    cout << "Doing high_bit_mask_t tests." << endl;
+    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 );
+    PRIVATE_LOW_BITS_TEST( 31 );
+    PRIVATE_LOW_BITS_TEST( 30 );
+    PRIVATE_LOW_BITS_TEST( 29 );
+    PRIVATE_LOW_BITS_TEST( 28 );
+    PRIVATE_LOW_BITS_TEST( 27 );
+    PRIVATE_LOW_BITS_TEST( 26 );
+    PRIVATE_LOW_BITS_TEST( 25 );
+    PRIVATE_LOW_BITS_TEST( 24 );
+    PRIVATE_LOW_BITS_TEST( 23 );
+    PRIVATE_LOW_BITS_TEST( 22 );
+    PRIVATE_LOW_BITS_TEST( 21 );
+    PRIVATE_LOW_BITS_TEST( 20 );
+    PRIVATE_LOW_BITS_TEST( 19 );
+    PRIVATE_LOW_BITS_TEST( 18 );
+    PRIVATE_LOW_BITS_TEST( 17 );
+    PRIVATE_LOW_BITS_TEST( 16 );
+    PRIVATE_LOW_BITS_TEST( 15 );
+    PRIVATE_LOW_BITS_TEST( 14 );
+    PRIVATE_LOW_BITS_TEST( 13 );
+    PRIVATE_LOW_BITS_TEST( 12 );
+    PRIVATE_LOW_BITS_TEST( 11 );
+    PRIVATE_LOW_BITS_TEST( 10 );
+    PRIVATE_LOW_BITS_TEST(  9 );
+    PRIVATE_LOW_BITS_TEST(  8 );
+    PRIVATE_LOW_BITS_TEST(  7 );
+    PRIVATE_LOW_BITS_TEST(  6 );
+    PRIVATE_LOW_BITS_TEST(  5 );
+    PRIVATE_LOW_BITS_TEST(  4 );
+    PRIVATE_LOW_BITS_TEST(  3 );
+    PRIVATE_LOW_BITS_TEST(  2 );
+    PRIVATE_LOW_BITS_TEST(  1 );
+
+    return boost::report_errors();
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,263 @@
+//  boost integer.hpp test program  ------------------------------------------//
+
+//  Copyright Beman Dawes 1999.  
+//  Copyright Daryle Walker 2001.  
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//  See http://www.boost.org/libs/integer for documentation.
+
+//  Revision History
+//   04 Oct 01  Added tests for new templates; rewrote code (Daryle Walker)
+//   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
+//   31 Aug 99  Initial version
+
+#include <boost/detail/lightweight_test.hpp>  // for main, BOOST_TEST
+#include <boost/integer.hpp>  // for boost::int_t, boost::uint_t
+#include <boost/type_traits/is_same.hpp>
+
+#include <climits>   // for ULONG_MAX, LONG_MAX, LONG_MIN
+#include <iostream>  // for std::cout (std::endl indirectly)
+#include <typeinfo>  // for std::type_info
+
+#ifdef BOOST_MSVC
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
+#if defined( __BORLANDC__ )
+# pragma option -w-8008 -w-8066 // condition is always true
+#endif
+
+//
+// Keep track of error count, so we can print out detailed
+// info only if we need it:
+//
+int last_error_count = 0;
+//
+// Helpers to print out the name of a type,
+// we use these as typeid(X).name() doesn't always
+// return a human readable string:
+//
+template <class T> const char* get_name_of_type(T){ return typeid(T).name(); }
+const char* get_name_of_type(signed char){ return "signed char"; }
+const char* get_name_of_type(unsigned char){ return "unsigned char"; }
+const char* get_name_of_type(short){ return "short"; }
+const char* get_name_of_type(unsigned short){ return "unsigned short"; }
+const char* get_name_of_type(int){ return "int"; }
+const char* get_name_of_type(unsigned int){ return "unsigned int"; }
+const char* get_name_of_type(long){ return "long"; }
+const char* get_name_of_type(unsigned long){ return "unsigned long"; }
+#ifdef BOOST_HAS_LONG_LONG
+const char* get_name_of_type(boost::long_long_type){ return "boost::long_long_type"; }
+const char* get_name_of_type(boost::ulong_long_type){ return "boost::ulong_long_type"; }
+#endif
+
+template <int Bits>
+void do_test_exact(boost::mpl::true_ const&)
+{
+   // Test the ::exact member:
+   typedef typename boost::int_t<Bits>::exact int_exact;
+   typedef typename boost::uint_t<Bits>::exact uint_exact;
+   typedef typename boost::int_t<Bits>::least least_int;
+   typedef typename boost::uint_t<Bits>::least least_uint;
+
+   BOOST_TEST((boost::is_same<int_exact, least_int>::value));
+   BOOST_TEST((boost::is_same<uint_exact, least_uint>::value));
+}
+template <int Bits>
+void do_test_exact(boost::mpl::false_ const&)
+{
+   // Nothing to do, type does not have an ::extact member.
+}
+
+template <int Bits>
+void do_test_bits()
+{
+   //
+   // Recurse to next smallest number of bits:
+   //
+   do_test_bits<Bits - 1>();
+   //
+   // Test exact types if we have them:
+   //
+   do_test_exact<Bits>(
+      boost::mpl::bool_<
+      (sizeof(unsigned char) * CHAR_BIT == Bits)
+      || (sizeof(unsigned short) * CHAR_BIT == Bits)
+      || (sizeof(unsigned int) * CHAR_BIT == Bits)
+      || (sizeof(unsigned long) * CHAR_BIT == Bits)
+#ifdef BOOST_HAS_LONG_LONG
+      || (sizeof(boost::ulong_long_type) * CHAR_BIT == Bits)
+#endif
+      >());
+   //
+   // We need to check all aspects of the members of int_t<Bits> and uint_t<Bits>:
+   //
+   typedef typename boost::int_t<Bits>::least least_int;
+   typedef typename boost::int_t<Bits>::least fast_int;
+   typedef typename boost::uint_t<Bits>::least least_uint;
+   typedef typename boost::uint_t<Bits>::fast fast_uint;
+
+   if(std::numeric_limits<least_int>::is_specialized)
+   {
+      BOOST_TEST(std::numeric_limits<least_int>::digits + 1 >= Bits);
+   }
+   if(std::numeric_limits<least_uint>::is_specialized)
+   {
+      BOOST_TEST(std::numeric_limits<least_uint>::digits >= Bits);
+   }
+   BOOST_TEST(sizeof(least_int) * CHAR_BIT >= Bits);
+   BOOST_TEST(sizeof(least_uint) * CHAR_BIT >= Bits);
+   BOOST_TEST(sizeof(fast_int) >= sizeof(least_int));
+   BOOST_TEST(sizeof(fast_uint) >= sizeof(least_uint));
+   //
+   // There should be no type smaller than least_* that also has enough bits:
+   //
+   if(!boost::is_same<signed char, least_int>::value)
+   {
+      BOOST_TEST(std::numeric_limits<signed char>::digits < Bits);
+      if(!boost::is_same<short, least_int>::value)
+      {
+         BOOST_TEST(std::numeric_limits<short>::digits < Bits);
+         if(!boost::is_same<int, least_int>::value)
+         {
+            BOOST_TEST(std::numeric_limits<int>::digits < Bits);
+            if(!boost::is_same<long, least_int>::value)
+            {
+               BOOST_TEST(std::numeric_limits<long>::digits < Bits);
+            }
+         }
+      }
+   }
+   // And again, but unsigned:
+   if(!boost::is_same<unsigned char, least_uint>::value)
+   {
+      BOOST_TEST(std::numeric_limits<unsigned char>::digits < Bits);
+      if(!boost::is_same<unsigned short, least_uint>::value)
+      {
+         BOOST_TEST(std::numeric_limits<unsigned short>::digits < Bits);
+         if(!boost::is_same<unsigned int, least_uint>::value)
+         {
+            BOOST_TEST(std::numeric_limits<unsigned int>::digits < Bits);
+            if(!boost::is_same<unsigned long, least_uint>::value)
+            {
+               BOOST_TEST(std::numeric_limits<unsigned long>::digits < Bits);
+            }
+         }
+      }
+   }
+
+   if(boost::detail::test_errors() != last_error_count)
+   {
+      last_error_count = boost::detail::test_errors();
+      std::cout << "Errors occured while testing with bit count = " << Bits << std::endl;
+      std::cout << "Type int_t<" << Bits << ">::least was " << get_name_of_type(least_int(0)) << std::endl;
+      std::cout << "Type int_t<" << Bits << ">::fast was " << get_name_of_type(fast_int(0)) << std::endl;
+      std::cout << "Type uint_t<" << Bits << ">::least was " << get_name_of_type(least_uint(0)) << std::endl;
+      std::cout << "Type uint_t<" << Bits << ">::fast was " << get_name_of_type(fast_uint(0)) << std::endl;
+   }
+}
+template <>
+void do_test_bits<-1>()
+{
+   // Nothing to do here!!
+}
+
+template <class Traits, class Expected>
+void test_min_max_type(Expected val)
+{
+   typedef typename Traits::least least_type;
+   typedef typename Traits::fast  fast_type;
+   BOOST_TEST((boost::is_same<least_type, Expected>::value));
+   BOOST_TEST(sizeof(fast_type) >= sizeof(least_type));
+   BOOST_TEST((std::numeric_limits<least_type>::min)() <= val);
+   BOOST_TEST((std::numeric_limits<least_type>::max)() >= val);
+
+   if(boost::detail::test_errors() != last_error_count)
+   {
+      last_error_count = boost::detail::test_errors();
+      std::cout << "Traits type is: " << typeid(Traits).name() << std::endl;
+      std::cout << "Least type is: " << get_name_of_type(least_type(0)) << std::endl;
+      std::cout << "Fast type is: " << get_name_of_type(fast_type(0)) << std::endl;
+      std::cout << "Expected type is: " << get_name_of_type(Expected(0)) << std::endl;
+      std::cout << "Required value is: " << val << std::endl;
+   }
+}
+
+// Test program
+int main(int, char*[])
+{
+   // Test int_t and unint_t first:
+   if(std::numeric_limits<boost::intmax_t>::is_specialized)
+      do_test_bits<std::numeric_limits<boost::uintmax_t>::digits>();
+   else
+      do_test_bits<std::numeric_limits<long>::digits>();
+
+   //
+   // Test min and max value types:
+   //
+   test_min_max_type<boost::int_max_value_t<SCHAR_MAX>, signed char>(SCHAR_MAX);
+   test_min_max_type<boost::int_min_value_t<SCHAR_MIN>, signed char>(SCHAR_MIN);
+   test_min_max_type<boost::uint_value_t<UCHAR_MAX>, unsigned char>(UCHAR_MAX);
+#if(USHRT_MAX != UCHAR_MAX)
+      test_min_max_type<boost::int_max_value_t<SCHAR_MAX+1>, short>(SCHAR_MAX+1);
+      test_min_max_type<boost::int_min_value_t<SCHAR_MIN-1>, short>(SCHAR_MIN-1);
+      test_min_max_type<boost::uint_value_t<UCHAR_MAX+1>, unsigned short>(UCHAR_MAX+1);
+      test_min_max_type<boost::int_max_value_t<SHRT_MAX>, short>(SHRT_MAX);
+      test_min_max_type<boost::int_min_value_t<SHRT_MIN>, short>(SHRT_MIN);
+      test_min_max_type<boost::uint_value_t<USHRT_MAX>, unsigned short>(USHRT_MAX);
+#endif
+#if(UINT_MAX != USHRT_MAX)
+      test_min_max_type<boost::int_max_value_t<SHRT_MAX+1>, int>(SHRT_MAX+1);
+      test_min_max_type<boost::int_min_value_t<SHRT_MIN-1>, int>(SHRT_MIN-1);
+      test_min_max_type<boost::uint_value_t<USHRT_MAX+1>, unsigned int>(USHRT_MAX+1);
+      test_min_max_type<boost::int_max_value_t<INT_MAX>, int>(INT_MAX);
+      test_min_max_type<boost::int_min_value_t<INT_MIN>, int>(INT_MIN);
+      test_min_max_type<boost::uint_value_t<UINT_MAX>, unsigned int>(UINT_MAX);
+#endif
+#if(ULONG_MAX != UINT_MAX)
+      test_min_max_type<boost::int_max_value_t<INT_MAX+1L>, long>(INT_MAX+1L);
+      test_min_max_type<boost::int_min_value_t<INT_MIN-1L>, long>(INT_MIN-1L);
+      test_min_max_type<boost::uint_value_t<UINT_MAX+1uL>, unsigned long>(UINT_MAX+1uL);
+      test_min_max_type<boost::int_max_value_t<LONG_MAX>, long>(LONG_MAX);
+      test_min_max_type<boost::int_min_value_t<LONG_MIN>, long>(LONG_MIN);
+      test_min_max_type<boost::uint_value_t<ULONG_MAX>, unsigned long>(ULONG_MAX);
+#endif
+#ifndef BOOST_NO_INTEGRAL_INT64_T
+#if defined(BOOST_HAS_LONG_LONG) && (defined(ULLONG_MAX) && (ULLONG_MAX != ULONG_MAX))
+      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
+      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
+      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
+      test_min_max_type<boost::int_max_value_t<LLONG_MAX>, boost::long_long_type>(LLONG_MAX);
+      test_min_max_type<boost::int_min_value_t<LLONG_MIN>, boost::long_long_type>(LLONG_MIN);
+      test_min_max_type<boost::uint_value_t<ULLONG_MAX>, boost::ulong_long_type>(ULLONG_MAX);
+#endif
+#if defined(BOOST_HAS_LONG_LONG) && (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX != ULONG_MAX))
+      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
+      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
+      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
+      test_min_max_type<boost::int_max_value_t<LONG_LONG_MAX>, boost::long_long_type>(LONG_LONG_MAX);
+      test_min_max_type<boost::int_min_value_t<LONG_LONG_MIN>, boost::long_long_type>(LONG_LONG_MIN);
+      test_min_max_type<boost::uint_value_t<ULONG_LONG_MAX>, boost::ulong_long_type>(ULONG_LONG_MAX);
+#endif
+#if defined(BOOST_HAS_LONG_LONG) && (defined(ULONGLONG_MAX) && (ULONGLONG_MAX != ULONG_MAX))
+      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
+      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
+      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
+      test_min_max_type<boost::int_max_value_t<LONGLONG_MAX>, boost::long_long_type>(LONGLONG_MAX);
+      test_min_max_type<boost::int_min_value_t<LONGLONG_MIN>, boost::long_long_type>(LONGLONG_MAX);
+      test_min_max_type<boost::uint_value_t<ULONGLONG_MAX>, boost::ulong_long_type>(ULONGLONG_MAX);
+#endif
+#if defined(BOOST_HAS_LONG_LONG) && (defined(_ULLONG_MAX) && defined(_LLONG_MIN) && (_ULLONG_MAX != ULONG_MAX))
+      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
+      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
+      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
+      test_min_max_type<boost::int_max_value_t<_LLONG_MAX>, boost::long_long_type>(_LLONG_MAX);
+      test_min_max_type<boost::int_min_value_t<_LLONG_MIN>, boost::long_long_type>(_LLONG_MIN);
+      test_min_max_type<boost::uint_value_t<_ULLONG_MAX>, boost::ulong_long_type>(_ULLONG_MAX);
+#endif // BOOST_HAS_LONG_LONG
+#endif // BOOST_NO_INTEGRAL_INT64_T
+      return boost::report_errors();
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_traits_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_traits_include_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,37 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer_traits.hpp> // must be the only #include!
+
+template <class T>
+void check_numeric_limits_derived(const std::numeric_limits<T>&){}
+
+template <class T>
+void check()
+{
+   typedef boost::integer_traits<T> traits;
+   check_numeric_limits_derived(traits());
+   bool b = traits::is_integral;
+   (void)b;
+   T v = traits::const_min + traits::const_max;
+   (void)v;
+}
+
+int main()
+{
+   check<signed char>();
+   check<unsigned char>();
+   check<char>();
+   check<short>();
+   check<unsigned short>();
+   check<int>();
+   check<unsigned int>();
+   check<signed long>();
+   check<unsigned long>();
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+   check<boost::long_long_type>();
+   check<boost::ulong_long_type>();
+#endif
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_traits_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/integer_traits_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,101 @@
+/* boost integer_traits.hpp tests
+ *
+ * Copyright Jens Maurer 2000
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * $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>
+
+#include <boost/detail/lightweight_test.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);
+#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
+  // MSVC++ 6.0 issues a LNK1179 error (duplicate comdat) when the compiler
+  // generates different symbol names with a very long common prefix:
+  // the dummy "&& true" disambiguates between the symbols generated by this
+  // BOOST_TEST instantiation and the preceding one.
+  BOOST_TEST(traits::is_integer && true);
+#else
+  BOOST_TEST(traits::is_integer);
+#endif
+  BOOST_TEST(traits::is_integral == true);
+  BOOST_TEST(traits::const_min == (traits::min)());
+  BOOST_TEST(traits::const_max == (traits::max)());
+}
+
+int 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());
+#ifndef BOOST_NO_INTEGRAL_INT64_T
+  //
+  // MS/Borland compilers can't support 64-bit member constants
+  // BeOS doesn't have specialisations for long long in SGI's <limits> header.
+  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 boost::report_errors();
+}
+

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_log2_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_log2_include_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,14 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer/static_log2.hpp> // must be the only #include!
+
+int main()
+{
+   boost::static_log2_argument_type arg = 0;
+   (void)arg;
+   boost::static_log2_result_type result = boost::static_log2<30>::value;
+   (void)result;
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_log2_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_log2_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,149 @@
+//  Boost static_log2.hpp test program  --------------------------------------//
+
+//  (C) Copyright Daryle Walker 2001.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  01 Oct 2001  Initial version (Daryle Walker)
+
+#include <boost/detail/lightweight_test.hpp>  // for main
+
+#include <boost/cstdlib.hpp>              // for boost::exit_success
+#include <boost/integer/static_log2.hpp>  // for boost::static_log2
+
+#include <iostream>  // for std::cout (std::endl indirectly)
+
+
+// Macros to compact code
+#define PRIVATE_LB_TEST( v, e )  BOOST_TEST( ::boost::static_log2<v>::value == e )
+
+#define PRIVATE_PRINT_LB( v )    ::std::cout << "boost::static_log2<" << (v) \
+ << "> = " << ::boost::static_log2< (v) >::value << '.' << ::std::endl
+
+// Control to check for a compile-time error
+#ifndef CONTROL_LB_0_TEST
+#define PRIVATE_LB_0_TEST
+#else
+#define PRIVATE_LB_0_TEST  PRIVATE_PRINT_LB( 0 )
+#endif
+
+
+// Main testing function
+int
+main
+(
+    int         ,   // "argc" is unused
+    char *      []  // "argv" is unused
+)
+{    
+    std::cout << "Doing tests on static_log2." << std::endl;
+
+    PRIVATE_LB_0_TEST;
+
+    PRIVATE_LB_TEST( 1, 0 );
+
+    PRIVATE_LB_TEST( 2, 1 );
+    PRIVATE_LB_TEST( 3, 1 );
+
+    PRIVATE_LB_TEST( 4, 2 );
+    PRIVATE_LB_TEST( 5, 2 );
+    PRIVATE_LB_TEST( 6, 2 );
+    PRIVATE_LB_TEST( 7, 2 );
+
+    PRIVATE_LB_TEST(  8, 3 );
+    PRIVATE_LB_TEST(  9, 3 );
+    PRIVATE_LB_TEST( 10, 3 );
+    PRIVATE_LB_TEST( 11, 3 );
+    PRIVATE_LB_TEST( 12, 3 );
+    PRIVATE_LB_TEST( 13, 3 );
+    PRIVATE_LB_TEST( 14, 3 );
+    PRIVATE_LB_TEST( 15, 3 );
+
+    PRIVATE_LB_TEST( 16, 4 );
+    PRIVATE_LB_TEST( 17, 4 );
+    PRIVATE_LB_TEST( 18, 4 );
+    PRIVATE_LB_TEST( 19, 4 );
+    PRIVATE_LB_TEST( 20, 4 );
+    PRIVATE_LB_TEST( 21, 4 );
+    PRIVATE_LB_TEST( 22, 4 );
+    PRIVATE_LB_TEST( 23, 4 );
+    PRIVATE_LB_TEST( 24, 4 );
+    PRIVATE_LB_TEST( 25, 4 );
+    PRIVATE_LB_TEST( 26, 4 );
+    PRIVATE_LB_TEST( 27, 4 );
+    PRIVATE_LB_TEST( 28, 4 );
+    PRIVATE_LB_TEST( 29, 4 );
+    PRIVATE_LB_TEST( 30, 4 );
+    PRIVATE_LB_TEST( 31, 4 );
+
+    PRIVATE_LB_TEST( 32, 5 );
+    PRIVATE_LB_TEST( 33, 5 );
+    PRIVATE_LB_TEST( 34, 5 );
+    PRIVATE_LB_TEST( 35, 5 );
+    PRIVATE_LB_TEST( 36, 5 );
+    PRIVATE_LB_TEST( 37, 5 );
+    PRIVATE_LB_TEST( 38, 5 );
+    PRIVATE_LB_TEST( 39, 5 );
+    PRIVATE_LB_TEST( 40, 5 );
+
+    PRIVATE_LB_TEST( 63, 5 );
+
+    PRIVATE_LB_TEST( 64, 6 );
+    PRIVATE_LB_TEST( 65, 6 );
+
+    PRIVATE_LB_TEST( 127, 6 );
+
+    PRIVATE_LB_TEST( 128, 7 );
+    PRIVATE_LB_TEST( 129, 7 );
+
+    PRIVATE_LB_TEST( 255, 7 );
+
+    PRIVATE_LB_TEST( 256, 8 );
+    PRIVATE_LB_TEST( 257, 8 );
+
+    PRIVATE_LB_TEST( 511, 8 );
+
+    PRIVATE_LB_TEST( 512, 9 );
+    PRIVATE_LB_TEST( 513, 9 );
+
+    PRIVATE_LB_TEST( 1023, 9 );
+
+    PRIVATE_LB_TEST( 1024, 10 );
+    PRIVATE_LB_TEST( 1025, 10 );
+
+    PRIVATE_LB_TEST( 2047, 10 );
+
+    PRIVATE_LB_TEST( 2048, 11 );
+    PRIVATE_LB_TEST( 2049, 11 );
+
+    PRIVATE_LB_TEST( 4095, 11 );
+
+    PRIVATE_LB_TEST( 4096, 12 );
+    PRIVATE_LB_TEST( 4097, 12 );
+
+    PRIVATE_LB_TEST( 8191, 12 );
+
+    PRIVATE_LB_TEST( 8192, 13 );
+    PRIVATE_LB_TEST( 8193, 13 );
+
+    PRIVATE_LB_TEST( 16383, 13 );
+
+    PRIVATE_LB_TEST( 16384, 14 );
+    PRIVATE_LB_TEST( 16385, 14 );
+
+    PRIVATE_LB_TEST( 32767, 14 );
+
+    PRIVATE_LB_TEST( 32768, 15 );
+    PRIVATE_LB_TEST( 32769, 15 );
+
+    PRIVATE_LB_TEST( 65535, 15 );
+
+    PRIVATE_LB_TEST( 65536, 16 );
+    PRIVATE_LB_TEST( 65537, 16 );
+
+    return boost::report_errors();
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_min_max_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_min_max_include_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,14 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer/static_min_max.hpp> // must be the only #include!
+
+int main()
+{
+   boost::static_min_max_signed_type m = boost::static_signed_min<2, 3>::value + boost::static_signed_max<2, 3>::value;
+   (void)m;
+   boost::static_min_max_unsigned_type u = boost::static_unsigned_min<2, 3>::value + boost::static_unsigned_max<2, 3>::value;
+   (void)u;
+}

Added: sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_min_max_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bits_and_ints/libs/integer/test/static_min_max_test.cpp	2010-05-01 23:45:50 EDT (Sat, 01 May 2010)
@@ -0,0 +1,92 @@
+//  Boost static_min_max.hpp test program  -----------------------------------//
+
+//  (C) Copyright Daryle Walker 2001.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  23 Sep 2001  Initial version (Daryle Walker)
+
+#include <boost/detail/lightweight_test.hpp>  // for main, BOOST_TEST
+
+#include <boost/cstdlib.hpp>                 // for boost::exit_success
+#include <boost/integer/static_min_max.hpp>  // for boost::static_signed_min, etc.
+
+#include <iostream>  // for std::cout (std::endl indirectly)
+
+
+// Main testing function
+int
+main
+(
+    int         ,   // "argc" is unused
+    char *      []  // "argv" is unused
+)
+{    
+    using std::cout;
+    using std::endl;
+    using boost::static_signed_min;
+    using boost::static_signed_max;
+    using boost::static_unsigned_min;
+    using boost::static_unsigned_max;
+
+    // Two positives
+    cout << "Doing tests with two positive values." << endl;
+
+    BOOST_TEST( (static_signed_min< 9, 14>::value) ==  9 );
+    BOOST_TEST( (static_signed_max< 9, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_min<14,  9>::value) ==  9 );
+    BOOST_TEST( (static_signed_max<14,  9>::value) == 14 );
+
+    BOOST_TEST( (static_unsigned_min< 9, 14>::value) ==  9 );
+    BOOST_TEST( (static_unsigned_max< 9, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14,  9>::value) ==  9 );
+    BOOST_TEST( (static_unsigned_max<14,  9>::value) == 14 );
+
+    // Two negatives
+    cout << "Doing tests with two negative values." << endl;
+
+    BOOST_TEST( (static_signed_min<  -8, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max<  -8, -101>::value) ==   -8 );
+    BOOST_TEST( (static_signed_min<-101,   -8>::value) == -101 );
+    BOOST_TEST( (static_signed_max<-101,   -8>::value) ==   -8 );
+
+    // With zero
+    cout << "Doing tests with zero and a positive or negative value." << endl;
+
+    BOOST_TEST( (static_signed_min< 0, 14>::value) ==  0 );
+    BOOST_TEST( (static_signed_max< 0, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_min<14,  0>::value) ==  0 );
+    BOOST_TEST( (static_signed_max<14,  0>::value) == 14 );
+
+    BOOST_TEST( (static_unsigned_min< 0, 14>::value) ==  0 );
+    BOOST_TEST( (static_unsigned_max< 0, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14,  0>::value) ==  0 );
+    BOOST_TEST( (static_unsigned_max<14,  0>::value) == 14 );
+
+    BOOST_TEST( (static_signed_min<   0, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max<   0, -101>::value) ==    0 );
+    BOOST_TEST( (static_signed_min<-101,    0>::value) == -101 );
+    BOOST_TEST( (static_signed_max<-101,    0>::value) ==    0 );
+
+    // With identical
+    cout << "Doing tests with two identical values." << endl;
+
+    BOOST_TEST( (static_signed_min<0, 0>::value) == 0 );
+    BOOST_TEST( (static_signed_max<0, 0>::value) == 0 );
+    BOOST_TEST( (static_unsigned_min<0, 0>::value) == 0 );
+    BOOST_TEST( (static_unsigned_max<0, 0>::value) == 0 );
+
+    BOOST_TEST( (static_signed_min<14, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_max<14, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max<14, 14>::value) == 14 );
+
+    BOOST_TEST( (static_signed_min< -101, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max< -101, -101>::value) == -101 );
+
+    return boost::report_errors();
+}