boostorg/integer
1
0
Fork 1
mirror of https://github.com/boostorg/integer.git synced 2025-07-26 02:37:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Integrated Daryle Walker's dlw_int.zip changes

Browse Source 
[SVN r11866]
This commit is contained in:
Dave Abrahams
2001-12-03 03:29:57 +00:00
parent 24e6bfbfaa
commit 162c6aefa1
4 changed files with 533 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
include/boost/integer.hpp
View File

@ -9,6 +9,7 @@
// See http://www.boost.org for most recent version including documentation.
// Revision History
// 22 Sep 01 Added value-based integer templates. (Daryle Walker)
// 01 Apr 01 Modified to use new <boost/limits.hpp> header. (John Maddock)
// 30 Jul 00 Add typename syntax fix (Jens Maurer)
// 28 Aug 99 Initial version
@ -16,7 +17,10 @@
#ifndef BOOST_INTEGER_HPP
#define BOOST_INTEGER_HPP
#include <boost/limits.hpp>
#include <boost/integer_fwd.hpp> // self include
#include <boost/integer_traits.hpp> // for boost::integer_traits
#include <boost/limits.hpp> // for std::numeric_limits
namespace boost
{
@ -75,11 +79,51 @@ namespace boost
// int_fast_t<> works correctly for unsigned too, in spite of the name.
};
// The same dispatching technique can be used to select types based on
// values. That will be added once boost::integer_traits is available.
// integer templates specifying extreme value ----------------------------//
// signed
template< long MaxValue > // maximum value to require support
struct int_max_value_t
{
typedef typename int_least_helper
<
(MaxValue <= integer_traits<long>::const_max) +
(MaxValue <= integer_traits<int>::const_max) +
(MaxValue <= integer_traits<short>::const_max) +
(MaxValue <= integer_traits<signed char>::const_max)
>::least least;
typedef typename int_fast_t<least>::fast fast;
};
template< long MinValue > // minimum value to require support
struct int_min_value_t
{
typedef typename int_least_helper
<
(MinValue >= integer_traits<long>::const_min) +
(MinValue >= integer_traits<int>::const_min) +
(MinValue >= integer_traits<short>::const_min) +
(MinValue >= integer_traits<signed char>::const_min)
>::least least;
typedef typename int_fast_t<least>::fast fast;
};
// unsigned
template< unsigned long Value > // maximum value to require support
struct uint_value_t
{
typedef typename int_least_helper
<
5 +
(Value <= integer_traits<unsigned long>::const_max) +
(Value <= integer_traits<unsigned int>::const_max) +
(Value <= integer_traits<unsigned short>::const_max) +
(Value <= integer_traits<unsigned char>::const_max)
>::least least;
typedef typename int_fast_t<least>::fast fast;
};
} // namespace boost
#endif // BOOST_INTEGER_HPP

112
index.htm
View File

@ -1,23 +1,18 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta http-equiv="Content-Language" content="en-us">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<title>Boost Integer Library</title>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table border="1" bgcolor="#007F7F" cellpadding="2">
<body bgcolor="white" text="black">
<table border="1" bgcolor="teal" cellpadding="2">
<tr>
<td bgcolor="#FFFFFF"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
<td><a href="../../index.htm"><font face="Arial" color="#FFFFFF"><big>Home </big></font></a></td>
<td><a href="../libraries.htm"><font face="Arial" color="#FFFFFF"><big>Libraries </big></font></a></td>
<td><a href="../../people/people.htm"><font face="Arial" color="#FFFFFF"><big>People </big></font></a></td>
<td><a href="../../more/faq.htm"><font face="Arial" color="#FFFFFF"><big>FAQ </big></font></a></td>
<td><a href="../../more/index.htm"><font face="Arial" color="#FFFFFF"><big>More </big></font></a></td>
<td bgcolor="white"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
<td><a href="../../index.htm"><font face="Arial" color="white"><big>Home</big></font></a></td>
<td><a href="../libraries.htm"><font face="Arial" color="white"><big>Libraries</big></font></a></td>
<td><a href="../../people/people.htm"><font face="Arial" color="white"><big>People</big></font></a></td>
<td><a href="../../more/faq.htm"><font face="Arial" color="white"><big>FAQ</big></font></a></td>
<td><a href="../../more/index.htm"><font face="Arial" color="white"><big>More</big></font></a></td>
</tr>
</table>
@ -25,9 +20,14 @@
<table border="1" cellpadding="5">
<tr>
<td align="center"><b><i>Header / Docs</i></b></td>
<td align="center"><b><i>Contents</i></b></td>
<td align="center"><b><i>Use</i></b></td>
<th>Header / Docs</th>
<th>Contents</th>
<th>Use</th>
</tr>
<tr>
<td align="center"><cite><a href="../../boost/integer_fwd.hpp">&lt;boost/integer_fwd.hpp&gt;</a></cite></td>
<td valign="top">Forward declarations of classes and class templates</td>
<td valign="top">When just the name of a class is needed</td>
</tr>
<tr>
<td align="center"><code><a href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;<br>
@ -59,40 +59,70 @@
<td valign="top">Use to select the type an integer when some property such as maximum value or number of bits is known.
Useful for generic programming. </td>
</tr>
<tr>
<td align="center"><code><a href="../../boost/integer/integer_mask.hpp">&lt;boost/integer/integer_mask.hpp&gt;</a><br>
<br>
</code><a href="doc/integer_mask.html">documentation</a></td>
<td valign="top">Templates for the selection of integer masks, single or lowest group, based on the number of bits.</td>
<td valign="top">Use to select a particular mask when the bit position(s) are based on a compile-time variable.
Useful for generic programming. </td>
</tr>
<tr>
<td align="center"><code><a href="../../boost/integer/static_log2.hpp">&lt;boost/integer/static_log2.hpp&gt;</a><br>
<br>
</code><a href="doc/static_log2.html">documentation</a></td>
<td valign="top">Template for finding the highest power of two in a number.</td>
<td valign="top">Use to find the bit-size/range based on a maximum value.
Useful for generic programming. </td>
</tr>
<tr>
<td align="center"><code><a href="../../boost/integer/static_min_max.hpp">&lt;boost/integer/static_min_max.hpp&gt;</a><br>
<br>
</code><a href="doc/static_min_max.html">documentation</a></td>
<td valign="top">Templates for finding the extrema of two numbers.</td>
<td valign="top">Use to find a bound based on a minimum or maximum value.
Useful for generic programming. </td>
</tr>
</table>
<h2>Rationale</h2>
<p>The organization of boost integer headers and classes is designed to take
advantage of <code>&lt;stdint.h&gt;</code> types from the 1999 C standard
without resorting to undefined behavior in terms of
the 1998 C++ standard.&nbsp; The header <code>&lt;boost/cstdint.hpp&gt;</code>
makes the standard integer types safely available in namespace boost without placing any names in namespace std. As always, the intension is to complement rather than
compete with the C++ Standard Library.&nbsp; Should some future C++ standard
include <code>&lt;stdint.h&gt;</code> and <code>&lt;cstdint&gt;</code>, then <code>&lt;boost/cstdint.hpp&gt;</code>
will continue to function, but will become redundant and may be safely deprecated.</p>
<p>Because these are boost headers, their names conform to boost header naming
conventions rather than C++ Standard Library header naming conventions.
<h2>Caveat emptor</h2>
<p>As an
implementation artifact, certain C &lt;limits.h&gt; macro names may possibly be
visible to users of &lt;boost/cstdint.hpp&gt;.&nbsp; Don't use these macros; they are not part of
any Boost specified interface.&nbsp;
Use boost:: integer_traits&lt;&gt; or std::numeric_limits&lt;&gt; instead.</p>
<p>The organization of boost integer headers and classes is designed to
take advantage of <cite>&lt;stdint.h&gt;</cite> types from the 1999 C
standard without resorting to undefined behavior in terms of the 1998
C++ standard. The header <cite>&lt;boost/cstdint.hpp&gt;</cite> makes
the standard integer types safely available in namespace
<code>boost</code> without placing any names in namespace
<code>std</code>. As always, the intension is to complement rather than
compete with the C++ Standard Library. Should some future C++ standard
include <cite>&lt;stdint.h&gt;</cite> and <cite>&lt;cstdint&gt;</cite>,
then <cite>&lt;boost/cstdint.hpp&gt;</cite> will continue to function,
but will become redundant and may be safely deprecated.</p>
<p>
As another implementation artifact, certain C
<code>&lt;stdint.h&gt;</code> typedef names may possibly be visible in the
global namespace to users of <code>&lt;boost/cstdint.hpp&gt;</code>.
Don't use these names, they are not part of any Boost specified
<p>Because these are boost headers, their names conform to boost header
naming conventions rather than C++ Standard Library header naming
conventions.</p>
<h2><i>Caveat emptor</i></h2>
<p>As an implementation artifact, certain C
<cite>&lt;limits.h&gt;</cite> macro names may possibly be visible to
users of <cite>&lt;boost/cstdint.hpp&gt;</cite>. Don't use these
macros; they are not part of any Boost-specified interface. Use
<code>boost::integer_traits&lt;&gt;</code> or
<code>std::numeric_limits&lt;&gt;</code> instead.</p>
<p>As another implementation artifact, certain C
<cite>&lt;stdint.h&gt;</cite> typedef names may possibly be visible in
the global namespace to users of <cite>&lt;boost/cstdint.hpp&gt;</cite>.
Don't use these names, they are not part of any Boost-specified
interface. Use the respective names in namespace <code>boost</code>
instead.
instead.</p>
<hr>
<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" -->
<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->03 Oct 2001<!--webbot bot="Timestamp" endspan i-checksum="14373" -->
</p>
</body>
</html>

232
integer.htm
View File

@ -1,112 +1,214 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<title>Integer Type Selection Templates</title>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<body bgcolor="white" text="black">
<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
align="middle" width="277" height="86">Integer Type Selection
Templates</h1>
<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Integer
Type Selection Templates</h1>
<p>The <code><a href="../../boost/integer.hpp">&lt;boost/integer.hpp&gt;</a></code>
type selection templates allow integer types to be selected based on desired
characteristics such as number of bits or maximum value.&nbsp; This facility is
particularly useful for solving generic programming problems.</p>
<p>The <cite><a
href="../../boost/integer.hpp">&lt;boost/integer.hpp&gt;</a></cite> type
selection templates allow integer types to be selected based on desired
characteristics such as number of bits or maximum value. This facility
is particularly useful for solving generic programming problems.</p>
<p>The templates <b>int_t&lt;&gt;</b> and <b>uint_t&lt;&gt;</b> supply typedefs <b>least</b>
and <b>fast</b>.&nbsp; The <b>least</b> type be the smallest type which holds at
least the number of bits (including sign) specified. The <b>fast</b> type will
be at least as large as the <b>least</b> type, but may possible be larger.&nbsp;
There is no guarantee that the <b>fast</b> type will actually be faster than
other possible types.</p>
<h2><a name="contents">Contents</a></h2>
<h2>Alternative</h2>
<ul>
<li><a href="#contents">Contents</a></li>
<li><a href="#synopsis">Synopsis</a></li>
<li><a href="#easy">Easiest-to-Manipulate Types</a></li>
<li><a href="#sized">Sized Types</a></li>
<li><a href="#example">Example</a></li>
<li><a href="#demo">Demonstration Program</a></li>
<li><a href="#rationale">Rationale</a></li>
<li><a href="#alternative">Alternative</a></li>
<li><a href="#credits">Credits</a></li>
</ul>
<p>If the number of bits required is known beforehand, it may be more
appropriate to use the types supplied in <code><a href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;</a></code>.</p>
<h2><a name="synopsis">Synopsis</a></h2>
<h2>Synopsis</h2>
<blockquote>
<pre>namespace boost
<blockquote><pre>
namespace boost
{
// fast integers from least integers
// int_fast_t&lt;&gt; works correctly for unsigned too, in spite of the name.
template&lt; typename LeastInt &gt; // Required: LeastInt is integral type, not bool
struct int_fast_t { typedef LeastInt fast; }; // implementations may specialize
template&lt; typename LeastInt &gt;
struct int_fast_t
{
typedef <em>implementation_supplied</em> fast;
};
// signed
template&lt; int Bits &gt; // bits (including sign) required, 0-32 valid
template&lt; int Bits &gt;
struct int_t
{
typedef <i>implementation-supplied</i> least;
typedef <em>implementation_supplied</em> least;
typedef int_fast_t&lt;least&gt;::fast fast;
};
// unsigned
template&lt; int Bits &gt; // bits required, 0-32 valid
template&lt; int Bits &gt;
struct uint_t
{
typedef <i>implementation-supplied</i> least;
typedef <em>implementation_supplied</em> least;
typedef int_fast_t&lt;least&gt;::fast fast;
};
// signed
template&lt; long MaxValue &gt;
struct int_max_value_t
{
typedef <em>implementation_supplied</em> least;
typedef int_fast_t&lt;least&gt;::fast fast;
};
template&lt; long MinValue &gt;
struct int_min_value_t
{
typedef <em>implementation_supplied</em> least;
typedef int_fast_t&lt;least&gt;::fast fast;
};
// unsigned
template&lt; unsigned long Value &gt;
struct uint_value_t
{
typedef <em>implementation_supplied</em> least;
typedef int_fast_t&lt;least&gt;::fast fast;
// int_fast_t&lt;&gt; works correctly for unsigned too, in spite of the name.
};
} // namespace boost
</pre>
</pre></blockquote>
</blockquote>
<p>[Templates to select type based on maximum value are under development.]
</p>
<h2><a name="easy">Easiest-to-Manipulate Types</a></h2>
<h2>Example</h2>
<p>The <code>int_fast_t</code> class template maps its input type to the
next-largest type that the processor can manipulate the easiest, or to
itself if the input type is already an easy-to-manipulate type. For
instance, processing a bunch of <code>char</code> objects may go faster
if they were converted to <code>int</code> objects before processing.
The input type, passed as the only template parameter, must be a
built-in integral type, except <code>bool</code>. Unsigned integral
types can be used, as well as signed integral types, despite the name.
The output type is given as the class member <code>fast</code>.</p>
<blockquote>
<pre>#include &lt;boost/integer.hpp&gt;
using boost::int_t;
<p><strong>Implementation Notes</strong><br>
By default, the output type is identical to the input type. Eventually,
this code's implementation should be conditionalized for each platform
to give accurate mappings between the built-in types and the
easiest-to-manipulate built-in types. Also, there is no guarantee that
the output type actually is easier to manipulate than the input
type.</p>
...
int_t&lt;24&gt;::least my_var; </pre>
<h2><a name="sized">Sized Types</a></h2>
</blockquote>
<h2>Demonstration Program</h2>
<p>The <code>int_t</code>, <code>uint_t</code>,
<code>int_max_value_t</code>, <code>int_min_value_t</code>, and
<code>uint_value_t</code> class templates find the most appropiate
built-in integral type for the given template parameter. This type is
given by the class member <code>least</code>. The easiest-to-manipulate
version of that type is given by the class member <code>fast</code>.
The following table describes each template's criteria.</p>
<p>The program <a href="integer_test.cpp">integer_test.cpp</a> is a not very
smart demonstration of the results from instantiating various <b>int_t&lt;&gt;</b>
and <b>uint_t&lt;&gt;</b> examples.</p>
<table border="1" cellpadding="5">
<caption>Criteria for the Sized Type Class Templates</caption>
<tr>
<th>Class Template</th>
<th>Template Parameter Mapping</th>
</tr>
<tr>
<td><code>boost::int_t</code></td>
<td>The smallest built-in signed integral type with at least the
given number of bits, including the sign bit. The parameter
should be a positive number. A compile-time error results if
the parameter is larger than the number of bits in a
<code>long</code>.</td>
</tr>
<tr>
<td><code>boost::uint_t</code></td>
<td>The smallest built-in unsigned integral type with at least
the given number of bits. The parameter should be a positive
number. A compile-time error results if the parameter is
larger than the number of bits in an <code>unsigned
long</code>.</td>
</tr>
<tr>
<td><code>boost::int_max_value_t</code></td>
<td>The smallest built-in signed integral type that supports the
given value as a maximum. The parameter should be a
positive number.</td>
</tr>
<tr>
<td><code>boost::int_min_value_t</code></td>
<td>The smallest built-in signed integral type that supports the
given value as a minimum. The parameter should be a
negative number.</td>
</tr>
<tr>
<td><code>boost::uint_value_t</code></td>
<td>The smallest built-in unsigned integral type that supports
the given value as a maximum. The parameter should be a
positive number.</td>
</tr>
</table>
<h2>Rationale</h2>
<h2><a name="example">Example</a></h2>
<blockquote><pre>
#include &lt;boost/integer.hpp&gt;
//...
int main()
{
boost::int_t&lt;24&gt;::least my_var;
//...
}
</pre></blockquote>
<h2><a name="demo">Demonstration Program</a></h2>
<p>The program <a href="integer_test.cpp">integer_test.cpp</a> is a
simplistic demonstration of the results from instantiating various
examples of the sized type class templates.</p>
<h2><a name="rationale">Rationale</a></h2>
<p>The rationale for the design of the templates in this header includes:</p>
<ul>
<li>Avoid&nbsp; recursion because of concern about C++'s limited guaranteed
recursion depth (17).</li>
<li>Avoid recursion because of concern about C++'s limited
guaranteed recursion depth (17).</li>
<li>Avoid macros on general principles.</li>
<li>Try to keep the design as simple as possible.</li>
</ul>
<h2>Credits</h2>
<h2><a name="alternative">Alternative</a></h2>
<p>The author of the Boost integer type choosing templates is <a href="../../people/beman_dawes.html">Beman
Dawes</a>.&nbsp; He thanks to <a href="../../people/valentin_bonnard.htm"> Valentin Bonnard</a> and
<a href="../../people/kevlin_henney.htm"> Kevlin Henney</a> for sharing their designs for similar templates.</p>
<p>If the number of bits required is known beforehand, it may be more
appropriate to use the types supplied in <cite><a
href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;</a></cite>.</p>
<h2><a name="credits">Credits</a></h2>
<p>The author of most of the Boost integer type choosing templates is <a
href="../../people/beman_dawes.html">Beman Dawes</a>. He gives thanks
to <a href="../../people/valentin_bonnard.htm">Valentin Bonnard</a> and
<a href="../../people/kevlin_henney.htm"> Kevlin Henney</a> for sharing
their designs for similar templates. <a
href="../../people/daryle_walker.html">Daryle Walker</a> designed the
value-based sized templates.</p>
<hr>
<p>Revised&nbsp; August 31, 1999</p>
<p><EFBFBD> Copyright Beman Dawes 1999. Permission to copy, use, modify, sell
and distribute this document is granted provided this copyright notice appears in all
copies. This document is provided &quot;as is&quot; without express or implied warranty,
and with no claim as to its suitability for any purpose.</p>
<p></p>
<p>&nbsp;</p>
<p>Revised May 20, 2001</p>
<p>&copy; Copyright Beman Dawes 1999. Permission to copy, use, modify,
sell and distribute this document is granted provided this copyright
notice appears in all copies. This document is provided &quot;as
is&quot; without express or implied warranty, and with no claim as to
its suitability for any purpose.</p>
</body>
</html>

512
integer_test.cpp
View File

@ -9,313 +9,247 @@
// See http://www.boost.org for most recent version including documentation.
// Revision History
// 04 Oct 01 Added tests for new templates; rewrote code (Daryle Walker)
// 10 Mar 01 Boost Test Library now used for tests (Beman Dawes)
// 31 Aug 99 Initial version
#include <iostream>
#include <boost/integer.hpp>
#define BOOST_INCLUDE_MAIN
#include <boost/test/test_tools.hpp>
#include <boost/test/test_tools.hpp> // for main, BOOST_TEST
namespace
{
void test( long ) { std::cout << "long\n"; }
void test( int ) { std::cout << "int\n"; }
void test( short ) { std::cout << "short\n"; }
void test( signed char ) { std::cout << "signed char\n"; }
void test( unsigned long ) { std::cout << "unsigned long\n"; }
void test( unsigned int ) { std::cout << "unsigned int\n"; }
void test( unsigned short ) { std::cout << "unsigned short\n"; }
void test( unsigned char ) { std::cout << "unsigned char\n"; }
} // unnamed namespace
#include <boost/config.hpp> // for BOOST_NO_USING_TEMPLATE
#include <boost/cstdlib.hpp> // for boost::exit_success
#include <boost/integer.hpp> // for boost::int_t, boost::uint_t
// just to prove it works, specialize int_fast_t<short> to yield long
#include <climits> // for ULONG_MAX, LONG_MAX, LONG_MIN
#include <iostream> // for std::cout (std::endl indirectly)
#include <typeinfo> // for std::type_info
// Control if the names of the types for each version
// of the integer templates will be printed.
#ifndef CONTROL_SHOW_TYPES
#define CONTROL_SHOW_TYPES 0
#endif
// If specializations have not already been done, then we can confirm
// the effects of the "fast" types by making a specialization.
namespace boost
{
template<> struct int_fast_t<short> { typedef long fast; };
template < >
struct int_fast_t< short >
{
typedef long fast;
};
}
int test_main(int,char**)
// Show the types of an integer template version
#if CONTROL_SHOW_TYPES
#define SHOW_TYPE(Template, Number, Type) ::std::cout << "Type \"" \
#Template "<" #Number ">::" #Type "\" is \"" << typeid(Template < \
Number > :: Type).name() << ".\"\n"
#else
#define SHOW_TYPE(Template, Number, Type)
#endif
#define SHOW_TYPES(Template, Type) SHOW_TYPE(Template, 32, Type); \
SHOW_TYPE(Template, 31, Type); SHOW_TYPE(Template, 30, Type); \
SHOW_TYPE(Template, 29, Type); SHOW_TYPE(Template, 28, Type); \
SHOW_TYPE(Template, 27, Type); SHOW_TYPE(Template, 26, Type); \
SHOW_TYPE(Template, 25, Type); SHOW_TYPE(Template, 24, Type); \
SHOW_TYPE(Template, 23, Type); SHOW_TYPE(Template, 22, Type); \
SHOW_TYPE(Template, 21, Type); SHOW_TYPE(Template, 20, Type); \
SHOW_TYPE(Template, 19, Type); SHOW_TYPE(Template, 18, Type); \
SHOW_TYPE(Template, 17, Type); SHOW_TYPE(Template, 16, Type); \
SHOW_TYPE(Template, 15, Type); SHOW_TYPE(Template, 14, Type); \
SHOW_TYPE(Template, 13, Type); SHOW_TYPE(Template, 12, Type); \
SHOW_TYPE(Template, 11, Type); SHOW_TYPE(Template, 10, Type); \
SHOW_TYPE(Template, 9, Type); SHOW_TYPE(Template, 8, Type); \
SHOW_TYPE(Template, 7, Type); SHOW_TYPE(Template, 6, Type); \
SHOW_TYPE(Template, 5, Type); SHOW_TYPE(Template, 4, Type); \
SHOW_TYPE(Template, 3, Type); SHOW_TYPE(Template, 2, Type); \
SHOW_TYPE(Template, 1, Type); SHOW_TYPE(Template, 0, Type)
#define SHOW_SHIFTED_TYPE(Template, Number, Type) SHOW_TYPE(Template, (1UL << Number), Type)
#define SHOW_SHIFTED_TYPES(Template, Type) SHOW_SHIFTED_TYPE(Template, 30, Type); \
SHOW_SHIFTED_TYPE(Template, 29, Type); SHOW_SHIFTED_TYPE(Template, 28, Type); \
SHOW_SHIFTED_TYPE(Template, 27, Type); SHOW_SHIFTED_TYPE(Template, 26, Type); \
SHOW_SHIFTED_TYPE(Template, 25, Type); SHOW_SHIFTED_TYPE(Template, 24, Type); \
SHOW_SHIFTED_TYPE(Template, 23, Type); SHOW_SHIFTED_TYPE(Template, 22, Type); \
SHOW_SHIFTED_TYPE(Template, 21, Type); SHOW_SHIFTED_TYPE(Template, 20, Type); \
SHOW_SHIFTED_TYPE(Template, 19, Type); SHOW_SHIFTED_TYPE(Template, 18, Type); \
SHOW_SHIFTED_TYPE(Template, 17, Type); SHOW_SHIFTED_TYPE(Template, 16, Type); \
SHOW_SHIFTED_TYPE(Template, 15, Type); SHOW_SHIFTED_TYPE(Template, 14, Type); \
SHOW_SHIFTED_TYPE(Template, 13, Type); SHOW_SHIFTED_TYPE(Template, 12, Type); \
SHOW_SHIFTED_TYPE(Template, 11, Type); SHOW_SHIFTED_TYPE(Template, 10, Type); \
SHOW_SHIFTED_TYPE(Template, 9, Type); SHOW_SHIFTED_TYPE(Template, 8, Type); \
SHOW_SHIFTED_TYPE(Template, 7, Type); SHOW_SHIFTED_TYPE(Template, 6, Type); \
SHOW_SHIFTED_TYPE(Template, 5, Type); SHOW_SHIFTED_TYPE(Template, 4, Type); \
SHOW_SHIFTED_TYPE(Template, 3, Type); SHOW_SHIFTED_TYPE(Template, 2, Type); \
SHOW_SHIFTED_TYPE(Template, 1, Type); SHOW_SHIFTED_TYPE(Template, 0, Type)
#define SHOW_POS_SHIFTED_TYPE(Template, Number, Type) SHOW_TYPE(Template, +(1L << Number), Type)
#define SHOW_POS_SHIFTED_TYPES(Template, Type) SHOW_POS_SHIFTED_TYPE(Template, 30, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 29, Type); SHOW_POS_SHIFTED_TYPE(Template, 28, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 27, Type); SHOW_POS_SHIFTED_TYPE(Template, 26, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 25, Type); SHOW_POS_SHIFTED_TYPE(Template, 24, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 23, Type); SHOW_POS_SHIFTED_TYPE(Template, 22, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 21, Type); SHOW_POS_SHIFTED_TYPE(Template, 20, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 19, Type); SHOW_POS_SHIFTED_TYPE(Template, 18, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 17, Type); SHOW_POS_SHIFTED_TYPE(Template, 16, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 15, Type); SHOW_POS_SHIFTED_TYPE(Template, 14, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 13, Type); SHOW_POS_SHIFTED_TYPE(Template, 12, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 11, Type); SHOW_POS_SHIFTED_TYPE(Template, 10, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 9, Type); SHOW_POS_SHIFTED_TYPE(Template, 8, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 7, Type); SHOW_POS_SHIFTED_TYPE(Template, 6, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 5, Type); SHOW_POS_SHIFTED_TYPE(Template, 4, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 3, Type); SHOW_POS_SHIFTED_TYPE(Template, 2, Type); \
SHOW_POS_SHIFTED_TYPE(Template, 1, Type); SHOW_POS_SHIFTED_TYPE(Template, 0, Type)
#define SHOW_NEG_SHIFTED_TYPE(Template, Number, Type) SHOW_TYPE(Template, -(1L << Number), Type)
#define SHOW_NEG_SHIFTED_TYPES(Template, Type) SHOW_NEG_SHIFTED_TYPE(Template, 30, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 29, Type); SHOW_NEG_SHIFTED_TYPE(Template, 28, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 27, Type); SHOW_NEG_SHIFTED_TYPE(Template, 26, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 25, Type); SHOW_NEG_SHIFTED_TYPE(Template, 24, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 23, Type); SHOW_NEG_SHIFTED_TYPE(Template, 22, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 21, Type); SHOW_NEG_SHIFTED_TYPE(Template, 20, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 19, Type); SHOW_NEG_SHIFTED_TYPE(Template, 18, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 17, Type); SHOW_NEG_SHIFTED_TYPE(Template, 16, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 15, Type); SHOW_NEG_SHIFTED_TYPE(Template, 14, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 13, Type); SHOW_NEG_SHIFTED_TYPE(Template, 12, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 11, Type); SHOW_NEG_SHIFTED_TYPE(Template, 10, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 9, Type); SHOW_NEG_SHIFTED_TYPE(Template, 8, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 7, Type); SHOW_NEG_SHIFTED_TYPE(Template, 6, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 5, Type); SHOW_NEG_SHIFTED_TYPE(Template, 4, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 3, Type); SHOW_NEG_SHIFTED_TYPE(Template, 2, Type); \
SHOW_NEG_SHIFTED_TYPE(Template, 1, Type); SHOW_NEG_SHIFTED_TYPE(Template, 0, Type)
// Test if a constant can fit within a certain type
#define PRIVATE_FIT_TEST(Template, Number, Type, Value) BOOST_TEST( Template < Number > :: Type ( Value ) == Value )
#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal) do { ValType v = InitVal ; PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
#define PRIVATE_SHIFTED_FIT_TEST(Template, Number, Type, Value) BOOST_TEST( Template < (ULONG_MAX >> Number) > :: Type ( Value ) == Value )
#define PRIVATE_SHIFTED_FIT_TESTS(Template, Type, ValType, InitVal) do { ValType v = InitVal ; \
PRIVATE_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
PRIVATE_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
#define PRIVATE_POS_SHIFTED_FIT_TEST(Template, Number, Type, Value) BOOST_TEST( Template < (LONG_MAX >> Number) > :: Type ( Value ) == Value )
#define PRIVATE_POS_FIT_TESTS(Template, Type, ValType, InitVal) do { ValType v = InitVal ; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
PRIVATE_POS_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
#define PRIVATE_NEG_SHIFTED_FIT_TEST(Template, Number, Type, Value) BOOST_TEST( Template < (LONG_MIN >> Number) > :: Type ( Value ) == Value )
#define PRIVATE_NEG_FIT_TESTS(Template, Type, ValType, InitVal) do { ValType v = InitVal ; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
// Test program
int
test_main
(
int,
char*[]
)
{
#ifndef BOOST_NO_USING_TEMPLATE
using boost::int_t;
using boost::uint_t;
using boost::int_max_value_t;
using boost::int_min_value_t;
using boost::uint_value_t;
#else
using namespace boost;
#endif
#ifdef BOOST_SHOW_TYPES
std::cout << 32 << ' '; test( int_t<32>::least() );
std::cout << 31 << ' '; test( int_t<31>::least() );
std::cout << 30 << ' '; test( int_t<30>::least() );
std::cout << 29 << ' '; test( int_t<29>::least() );
std::cout << 28 << ' '; test( int_t<28>::least() );
std::cout << 27 << ' '; test( int_t<27>::least() );
std::cout << 26 << ' '; test( int_t<26>::least() );
std::cout << 25 << ' '; test( int_t<25>::least() );
std::cout << 24 << ' '; test( int_t<24>::least() );
std::cout << 23 << ' '; test( int_t<23>::least() );
std::cout << 22 << ' '; test( int_t<22>::least() );
std::cout << 21 << ' '; test( int_t<21>::least() );
std::cout << 20 << ' '; test( int_t<20>::least() );
std::cout << 19 << ' '; test( int_t<19>::least() );
std::cout << 18 << ' '; test( int_t<18>::least() );
std::cout << 17 << ' '; test( int_t<17>::least() );
std::cout << 16 << ' '; test( int_t<16>::least() );
std::cout << 15 << ' '; test( int_t<15>::least() );
std::cout << 14 << ' '; test( int_t<14>::least() );
std::cout << 13 << ' '; test( int_t<13>::least() );
std::cout << 12 << ' '; test( int_t<12>::least() );
std::cout << 11 << ' '; test( int_t<11>::least() );
std::cout << 10 << ' '; test( int_t<10>::least() );
std::cout << 9 << ' '; test( int_t<9>::least() );
std::cout << 8 << ' '; test( int_t<8>::least() );
std::cout << 7 << ' '; test( int_t<7>::least() );
std::cout << 6 << ' '; test( int_t<6>::least() );
std::cout << 5 << ' '; test( int_t<5>::least() );
std::cout << 4 << ' '; test( int_t<4>::least() );
std::cout << 3 << ' '; test( int_t<3>::least() );
std::cout << 2 << ' '; test( int_t<2>::least() );
std::cout << 1 << ' '; test( int_t<1>::least() );
std::cout << 0 << ' '; test( int_t<0>::least() );
std::cout << 32 << ' '; test( int_t<32>::fast() );
std::cout << 31 << ' '; test( int_t<31>::fast() );
std::cout << 30 << ' '; test( int_t<30>::fast() );
std::cout << 29 << ' '; test( int_t<29>::fast() );
std::cout << 28 << ' '; test( int_t<28>::fast() );
std::cout << 27 << ' '; test( int_t<27>::fast() );
std::cout << 26 << ' '; test( int_t<26>::fast() );
std::cout << 25 << ' '; test( int_t<25>::fast() );
std::cout << 24 << ' '; test( int_t<24>::fast() );
std::cout << 23 << ' '; test( int_t<23>::fast() );
std::cout << 22 << ' '; test( int_t<22>::fast() );
std::cout << 21 << ' '; test( int_t<21>::fast() );
std::cout << 20 << ' '; test( int_t<20>::fast() );
std::cout << 19 << ' '; test( int_t<19>::fast() );
std::cout << 18 << ' '; test( int_t<18>::fast() );
std::cout << 17 << ' '; test( int_t<17>::fast() );
std::cout << 16 << ' '; test( int_t<16>::fast() );
std::cout << 15 << ' '; test( int_t<15>::fast() );
std::cout << 14 << ' '; test( int_t<14>::fast() );
std::cout << 13 << ' '; test( int_t<13>::fast() );
std::cout << 12 << ' '; test( int_t<12>::fast() );
std::cout << 11 << ' '; test( int_t<11>::fast() );
std::cout << 10 << ' '; test( int_t<10>::fast() );
std::cout << 9 << ' '; test( int_t<9>::fast() );
std::cout << 8 << ' '; test( int_t<8>::fast() );
std::cout << 7 << ' '; test( int_t<7>::fast() );
std::cout << 6 << ' '; test( int_t<6>::fast() );
std::cout << 5 << ' '; test( int_t<5>::fast() );
std::cout << 4 << ' '; test( int_t<4>::fast() );
std::cout << 3 << ' '; test( int_t<3>::fast() );
std::cout << 2 << ' '; test( int_t<2>::fast() );
std::cout << 1 << ' '; test( int_t<1>::fast() );
std::cout << 0 << ' '; test( int_t<0>::fast() );
std::cout << 32 << ' '; test( uint_t<32>::least() );
std::cout << 31 << ' '; test( uint_t<31>::least() );
std::cout << 30 << ' '; test( uint_t<30>::least() );
std::cout << 29 << ' '; test( uint_t<29>::least() );
std::cout << 28 << ' '; test( uint_t<28>::least() );
std::cout << 27 << ' '; test( uint_t<27>::least() );
std::cout << 26 << ' '; test( uint_t<26>::least() );
std::cout << 25 << ' '; test( uint_t<25>::least() );
std::cout << 24 << ' '; test( uint_t<24>::least() );
std::cout << 23 << ' '; test( uint_t<23>::least() );
std::cout << 22 << ' '; test( uint_t<22>::least() );
std::cout << 21 << ' '; test( uint_t<21>::least() );
std::cout << 20 << ' '; test( uint_t<20>::least() );
std::cout << 19 << ' '; test( uint_t<19>::least() );
std::cout << 18 << ' '; test( uint_t<18>::least() );
std::cout << 17 << ' '; test( uint_t<17>::least() );
std::cout << 16 << ' '; test( uint_t<16>::least() );
std::cout << 15 << ' '; test( uint_t<15>::least() );
std::cout << 14 << ' '; test( uint_t<14>::least() );
std::cout << 13 << ' '; test( uint_t<13>::least() );
std::cout << 12 << ' '; test( uint_t<12>::least() );
std::cout << 11 << ' '; test( uint_t<11>::least() );
std::cout << 10 << ' '; test( uint_t<10>::least() );
std::cout << 9 << ' '; test( uint_t<9>::least() );
std::cout << 8 << ' '; test( uint_t<8>::least() );
std::cout << 7 << ' '; test( uint_t<7>::least() );
std::cout << 6 << ' '; test( uint_t<6>::least() );
std::cout << 5 << ' '; test( uint_t<5>::least() );
std::cout << 4 << ' '; test( uint_t<4>::least() );
std::cout << 3 << ' '; test( uint_t<3>::least() );
std::cout << 2 << ' '; test( uint_t<2>::least() );
std::cout << 1 << ' '; test( uint_t<1>::least() );
std::cout << 0 << ' '; test( uint_t<0>::least() );
std::cout << 32 << ' '; test( uint_t<32>::fast() );
std::cout << 31 << ' '; test( uint_t<31>::fast() );
std::cout << 30 << ' '; test( uint_t<30>::fast() );
std::cout << 29 << ' '; test( uint_t<29>::fast() );
std::cout << 28 << ' '; test( uint_t<28>::fast() );
std::cout << 27 << ' '; test( uint_t<27>::fast() );
std::cout << 26 << ' '; test( uint_t<26>::fast() );
std::cout << 25 << ' '; test( uint_t<25>::fast() );
std::cout << 24 << ' '; test( uint_t<24>::fast() );
std::cout << 23 << ' '; test( uint_t<23>::fast() );
std::cout << 22 << ' '; test( uint_t<22>::fast() );
std::cout << 21 << ' '; test( uint_t<21>::fast() );
std::cout << 20 << ' '; test( uint_t<20>::fast() );
std::cout << 19 << ' '; test( uint_t<19>::fast() );
std::cout << 18 << ' '; test( uint_t<18>::fast() );
std::cout << 17 << ' '; test( uint_t<17>::fast() );
std::cout << 16 << ' '; test( uint_t<16>::fast() );
std::cout << 15 << ' '; test( uint_t<15>::fast() );
std::cout << 14 << ' '; test( uint_t<14>::fast() );
std::cout << 13 << ' '; test( uint_t<13>::fast() );
std::cout << 12 << ' '; test( uint_t<12>::fast() );
std::cout << 11 << ' '; test( uint_t<11>::fast() );
std::cout << 10 << ' '; test( uint_t<10>::fast() );
std::cout << 9 << ' '; test( uint_t<9>::fast() );
std::cout << 8 << ' '; test( uint_t<8>::fast() );
std::cout << 7 << ' '; test( uint_t<7>::fast() );
std::cout << 6 << ' '; test( uint_t<6>::fast() );
std::cout << 5 << ' '; test( uint_t<5>::fast() );
std::cout << 4 << ' '; test( uint_t<4>::fast() );
std::cout << 3 << ' '; test( uint_t<3>::fast() );
std::cout << 2 << ' '; test( uint_t<2>::fast() );
std::cout << 1 << ' '; test( uint_t<1>::fast() );
std::cout << 0 << ' '; test( uint_t<0>::fast() );
#endif
SHOW_TYPES( int_t, least );
SHOW_TYPES( int_t, fast );
SHOW_TYPES( uint_t, least );
SHOW_TYPES( uint_t, fast );
SHOW_POS_SHIFTED_TYPES( int_max_value_t, least );
SHOW_POS_SHIFTED_TYPES( int_max_value_t, fast );
SHOW_NEG_SHIFTED_TYPES( int_min_value_t, least );
SHOW_NEG_SHIFTED_TYPES( int_min_value_t, fast );
SHOW_SHIFTED_TYPES( uint_value_t, least );
SHOW_SHIFTED_TYPES( uint_value_t, fast );
long v = 0x7FFFFFFF;
BOOST_TEST( int_t<32>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<31>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<30>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<29>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<28>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<27>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<26>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<25>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<24>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<23>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<22>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<21>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<20>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<19>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<18>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<17>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<16>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<15>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<14>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<13>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<12>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<11>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<10>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<9>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<8>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<7>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<6>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<5>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<4>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<3>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<2>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<1>::least(v) == v ); v >>= 1;
BOOST_TEST( int_t<0>::least(v) == v );
v = 0x7FFFFFFF;
BOOST_TEST( int_t<32>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<31>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<30>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<29>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<28>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<27>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<26>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<25>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<24>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<23>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<22>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<21>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<20>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<19>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<18>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<17>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<16>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<15>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<14>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<13>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<12>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<11>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<10>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<9>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<8>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<7>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<6>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<5>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<4>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<3>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<2>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<1>::fast(v) == v ); v >>= 1;
BOOST_TEST( int_t<0>::fast(v) == v );
unsigned long u = 0xFFFFFFFF;
BOOST_TEST( uint_t<32>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<31>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<30>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<29>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<28>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<27>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<26>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<25>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<24>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<23>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<22>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<21>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<20>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<19>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<18>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<17>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<16>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<15>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<14>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<13>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<11>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<12>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<10>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<9>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<8>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<7>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<6>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<5>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<4>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<3>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<2>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<1>::least(u) == u ); u >>= 1;
BOOST_TEST( uint_t<0>::least(u) == u );
u = 0xFFFFFFFF;
BOOST_TEST( uint_t<32>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<31>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<30>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<29>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<28>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<27>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<26>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<25>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<24>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<23>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<22>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<21>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<20>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<19>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<18>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<17>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<16>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<15>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<14>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<13>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<12>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<11>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<10>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<9>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<8>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<7>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<6>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<5>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<4>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<3>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<2>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<1>::fast(u) == u ); u >>= 1;
BOOST_TEST( uint_t<0>::fast(u) == u );
PRIVATE_FIT_TESTS( int_t, least, long, LONG_MAX );
PRIVATE_FIT_TESTS( int_t, fast, long, LONG_MAX );
PRIVATE_FIT_TESTS( uint_t, least, unsigned long, ULONG_MAX );
PRIVATE_FIT_TESTS( uint_t, fast, unsigned long, ULONG_MAX );
PRIVATE_POS_FIT_TESTS( int_max_value_t, least, long, LONG_MAX );
PRIVATE_POS_FIT_TESTS( int_max_value_t, fast, long, LONG_MAX );
PRIVATE_NEG_FIT_TESTS( int_min_value_t, least, long, LONG_MIN );
PRIVATE_NEG_FIT_TESTS( int_min_value_t, fast, long, LONG_MIN );
PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, least, unsigned long, ULONG_MAX );
PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, fast, unsigned long, ULONG_MAX );
return 0;
return boost::exit_success;
}