mirror of
https://github.com/boostorg/integer.git
synced 2025-07-29 04:07:14 +02:00
Integrated Daryle Walker's dlw_int.zip changes
[SVN r11866]
This commit is contained in:
Dave Abrahams
@ -9,6 +9,7 @@
|
|||||||
// See http://www.boost.org for most recent version including documentation.
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
|
||||||
// Revision History
|
// 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)
|
// 01 Apr 01 Modified to use new <boost/limits.hpp> header. (John Maddock)
|
||||||
// 30 Jul 00 Add typename syntax fix (Jens Maurer)
|
// 30 Jul 00 Add typename syntax fix (Jens Maurer)
|
||||||
// 28 Aug 99 Initial version
|
// 28 Aug 99 Initial version
|
||||||
@ -16,7 +17,10 @@
|
|||||||
#ifndef BOOST_INTEGER_HPP
|
#ifndef BOOST_INTEGER_HPP
|
||||||
#define 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
|
namespace boost
|
||||||
{
|
{
|
||||||
@ -75,11 +79,51 @@ namespace boost
|
|||||||
// int_fast_t<> works correctly for unsigned too, in spite of the name.
|
// int_fast_t<> works correctly for unsigned too, in spite of the name.
|
||||||
};
|
};
|
||||||
|
|
||||||
// The same dispatching technique can be used to select types based on
|
// integer templates specifying extreme value ----------------------------//
|
||||||
// values. That will be added once boost::integer_traits is available.
|
|
||||||
|
// signed
|
||||||
|
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
|
} // namespace boost
|
||||||
|
|
||||||
#endif // BOOST_INTEGER_HPP
|
#endif // BOOST_INTEGER_HPP
|
||||||
|
|
||||||
|
|||||||
112
index.htm
112
index.htm
@ -1,23 +1,18 @@
|
|||||||
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
|
||||||
<html>
|
<html>
|
||||||
|
|
||||||
<head>
|
<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>
|
<title>Boost Integer Library</title>
|
||||||
</head>
|
</head>
|
||||||
|
|
||||||
<body bgcolor="#FFFFFF" text="#000000">
|
<body bgcolor="white" text="black">
|
||||||
|
<table border="1" bgcolor="teal" cellpadding="2">
|
||||||
<table border="1" bgcolor="#007F7F" cellpadding="2">
|
|
||||||
<tr>
|
<tr>
|
||||||
<td bgcolor="#FFFFFF"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
|
<td bgcolor="white"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
|
||||||
<td><a href="../../index.htm"><font face="Arial" color="#FFFFFF"><big>Home </big></font></a></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="#FFFFFF"><big>Libraries </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="#FFFFFF"><big>People </big></font></a></td>
|
<td><a href="../../people/people.htm"><font face="Arial" color="white"><big>People</big></font></a></td>
|
||||||
<td><a href="../../more/faq.htm"><font face="Arial" color="#FFFFFF"><big>FAQ </big></font></a></td>
|
<td><a href="../../more/faq.htm"><font face="Arial" color="white"><big>FAQ</big></font></a></td>
|
||||||
<td><a href="../../more/index.htm"><font face="Arial" color="#FFFFFF"><big>More </big></font></a></td>
|
<td><a href="../../more/index.htm"><font face="Arial" color="white"><big>More</big></font></a></td>
|
||||||
</tr>
|
</tr>
|
||||||
</table>
|
</table>
|
||||||
|
|
||||||
@ -25,9 +20,14 @@
|
|||||||
|
|
||||||
<table border="1" cellpadding="5">
|
<table border="1" cellpadding="5">
|
||||||
<tr>
|
<tr>
|
||||||
<td align="center"><b><i>Header / Docs</i></b></td>
|
<th>Header / Docs</th>
|
||||||
<td align="center"><b><i>Contents</i></b></td>
|
<th>Contents</th>
|
||||||
<td align="center"><b><i>Use</i></b></td>
|
<th>Use</th>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td align="center"><cite><a href="../../boost/integer_fwd.hpp"><boost/integer_fwd.hpp></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>
|
||||||
<tr>
|
<tr>
|
||||||
<td align="center"><code><a href="../../boost/cstdint.hpp"><boost/cstdint.hpp><br>
|
<td align="center"><code><a href="../../boost/cstdint.hpp"><boost/cstdint.hpp><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.
|
<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>
|
Useful for generic programming. </td>
|
||||||
</tr>
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td align="center"><code><a href="../../boost/integer/integer_mask.hpp"><boost/integer/integer_mask.hpp></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"><boost/integer/static_log2.hpp></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"><boost/integer/static_min_max.hpp></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>
|
</table>
|
||||||
|
|
||||||
<h2>Rationale</h2>
|
<h2>Rationale</h2>
|
||||||
<p>The organization of boost integer headers and classes is designed to take
|
|
||||||
advantage of <code><stdint.h></code> types from the 1999 C standard
|
|
||||||
without resorting to undefined behavior in terms of
|
|
||||||
the 1998 C++ standard. The header <code><boost/cstdint.hpp></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. Should some future C++ standard
|
|
||||||
include <code><stdint.h></code> and <code><cstdint></code>, then <code><boost/cstdint.hpp></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>The organization of boost integer headers and classes is designed to
|
||||||
<p>As an
|
take advantage of <cite><stdint.h></cite> types from the 1999 C
|
||||||
implementation artifact, certain C <limits.h> macro names may possibly be
|
standard without resorting to undefined behavior in terms of the 1998
|
||||||
visible to users of <boost/cstdint.hpp>. Don't use these macros; they are not part of
|
C++ standard. The header <cite><boost/cstdint.hpp></cite> makes
|
||||||
any Boost specified interface.
|
the standard integer types safely available in namespace
|
||||||
Use boost:: integer_traits<> or std::numeric_limits<> instead.</p>
|
<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><stdint.h></cite> and <cite><cstdint></cite>,
|
||||||
|
then <cite><boost/cstdint.hpp></cite> will continue to function,
|
||||||
|
but will become redundant and may be safely deprecated.</p>
|
||||||
|
|
||||||
<p>
|
<p>Because these are boost headers, their names conform to boost header
|
||||||
As another implementation artifact, certain C
|
naming conventions rather than C++ Standard Library header naming
|
||||||
<code><stdint.h></code> typedef names may possibly be visible in the
|
conventions.</p>
|
||||||
global namespace to users of <code><boost/cstdint.hpp></code>.
|
|
||||||
Don't use these names, they are not part of any Boost specified
|
<h2><i>Caveat emptor</i></h2>
|
||||||
|
|
||||||
|
<p>As an implementation artifact, certain C
|
||||||
|
<cite><limits.h></cite> macro names may possibly be visible to
|
||||||
|
users of <cite><boost/cstdint.hpp></cite>. Don't use these
|
||||||
|
macros; they are not part of any Boost-specified interface. Use
|
||||||
|
<code>boost::integer_traits<></code> or
|
||||||
|
<code>std::numeric_limits<></code> instead.</p>
|
||||||
|
|
||||||
|
<p>As another implementation artifact, certain C
|
||||||
|
<cite><stdint.h></cite> typedef names may possibly be visible in
|
||||||
|
the global namespace to users of <cite><boost/cstdint.hpp></cite>.
|
||||||
|
Don't use these names, they are not part of any Boost-specified
|
||||||
interface. Use the respective names in namespace <code>boost</code>
|
interface. Use the respective names in namespace <code>boost</code>
|
||||||
instead.
|
instead.</p>
|
||||||
|
|
||||||
<hr>
|
<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>
|
</p>
|
||||||
|
|
||||||
</body>
|
</body>
|
||||||
|
|
||||||
</html>
|
</html>
|
||||||
|
|||||||
232
integer.htm
232
integer.htm
@ -1,112 +1,214 @@
|
|||||||
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
|
||||||
<html>
|
<html>
|
||||||
|
|
||||||
<head>
|
<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>
|
<title>Integer Type Selection Templates</title>
|
||||||
</head>
|
</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
|
<p>The <cite><a
|
||||||
Type Selection Templates</h1>
|
href="../../boost/integer.hpp"><boost/integer.hpp></a></cite> type
|
||||||
<p>The <code><a href="../../boost/integer.hpp"><boost/integer.hpp></a></code>
|
selection templates allow integer types to be selected based on desired
|
||||||
type selection templates allow integer types to be selected based on desired
|
characteristics such as number of bits or maximum value. This facility
|
||||||
characteristics such as number of bits or maximum value. This facility is
|
is particularly useful for solving generic programming problems.</p>
|
||||||
particularly useful for solving generic programming problems.</p>
|
|
||||||
|
|
||||||
<p>The templates <b>int_t<></b> and <b>uint_t<></b> supply typedefs <b>least</b>
|
<h2><a name="contents">Contents</a></h2>
|
||||||
and <b>fast</b>. 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.
|
|
||||||
There is no guarantee that the <b>fast</b> type will actually be faster than
|
|
||||||
other possible types.</p>
|
|
||||||
|
|
||||||
<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
|
<h2><a name="synopsis">Synopsis</a></h2>
|
||||||
appropriate to use the types supplied in <code><a href="../../boost/cstdint.hpp"><boost/cstdint.hpp></a></code>.</p>
|
|
||||||
|
|
||||||
<h2>Synopsis</h2>
|
<blockquote><pre>
|
||||||
|
namespace boost
|
||||||
<blockquote>
|
|
||||||
<pre>namespace boost
|
|
||||||
{
|
{
|
||||||
// fast integers from least integers
|
// fast integers from least integers
|
||||||
// int_fast_t<> works correctly for unsigned too, in spite of the name.
|
template< typename LeastInt >
|
||||||
template< typename LeastInt > // Required: LeastInt is integral type, not bool
|
struct int_fast_t
|
||||||
struct int_fast_t { typedef LeastInt fast; }; // implementations may specialize
|
{
|
||||||
|
typedef <em>implementation_supplied</em> fast;
|
||||||
|
};
|
||||||
|
|
||||||
// signed
|
// signed
|
||||||
template< int Bits > // bits (including sign) required, 0-32 valid
|
template< int Bits >
|
||||||
struct int_t
|
struct int_t
|
||||||
{
|
{
|
||||||
typedef <i>implementation-supplied</i> least;
|
typedef <em>implementation_supplied</em> least;
|
||||||
typedef int_fast_t<least>::fast fast;
|
typedef int_fast_t<least>::fast fast;
|
||||||
};
|
};
|
||||||
|
|
||||||
// unsigned
|
// unsigned
|
||||||
template< int Bits > // bits required, 0-32 valid
|
template< int Bits >
|
||||||
struct uint_t
|
struct uint_t
|
||||||
{
|
{
|
||||||
typedef <i>implementation-supplied</i> least;
|
typedef <em>implementation_supplied</em> least;
|
||||||
|
typedef int_fast_t<least>::fast fast;
|
||||||
|
};
|
||||||
|
|
||||||
|
// signed
|
||||||
|
template< long MaxValue >
|
||||||
|
struct int_max_value_t
|
||||||
|
{
|
||||||
|
typedef <em>implementation_supplied</em> least;
|
||||||
|
typedef int_fast_t<least>::fast fast;
|
||||||
|
};
|
||||||
|
|
||||||
|
template< long MinValue >
|
||||||
|
struct int_min_value_t
|
||||||
|
{
|
||||||
|
typedef <em>implementation_supplied</em> least;
|
||||||
|
typedef int_fast_t<least>::fast fast;
|
||||||
|
};
|
||||||
|
|
||||||
|
// unsigned
|
||||||
|
template< unsigned long Value >
|
||||||
|
struct uint_value_t
|
||||||
|
{
|
||||||
|
typedef <em>implementation_supplied</em> least;
|
||||||
typedef int_fast_t<least>::fast fast;
|
typedef int_fast_t<least>::fast fast;
|
||||||
// int_fast_t<> works correctly for unsigned too, in spite of the name.
|
|
||||||
};
|
};
|
||||||
} // namespace boost
|
} // namespace boost
|
||||||
</pre>
|
</pre></blockquote>
|
||||||
|
|
||||||
</blockquote>
|
<h2><a name="easy">Easiest-to-Manipulate Types</a></h2>
|
||||||
<p>[Templates to select type based on maximum value are under development.]
|
|
||||||
</p>
|
|
||||||
|
|
||||||
<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>
|
<p><strong>Implementation Notes</strong><br>
|
||||||
<pre>#include <boost/integer.hpp>
|
By default, the output type is identical to the input type. Eventually,
|
||||||
using boost::int_t;
|
this code's implementation should be conditionalized for each platform
|
||||||
|
to give accurate mappings between the built-in types and the
|
||||||
|
easiest-to-manipulate built-in types. Also, there is no guarantee that
|
||||||
|
the output type actually is easier to manipulate than the input
|
||||||
|
type.</p>
|
||||||
|
|
||||||
...
|
<h2><a name="sized">Sized Types</a></h2>
|
||||||
int_t<24>::least my_var; </pre>
|
|
||||||
|
|
||||||
</blockquote>
|
<p>The <code>int_t</code>, <code>uint_t</code>,
|
||||||
<h2>Demonstration Program</h2>
|
<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
|
<table border="1" cellpadding="5">
|
||||||
smart demonstration of the results from instantiating various <b>int_t<></b>
|
<caption>Criteria for the Sized Type Class Templates</caption>
|
||||||
and <b>uint_t<></b> examples.</p>
|
<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 <boost/integer.hpp>
|
||||||
|
|
||||||
|
//...
|
||||||
|
|
||||||
|
int main()
|
||||||
|
{
|
||||||
|
boost::int_t<24>::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>
|
<p>The rationale for the design of the templates in this header includes:</p>
|
||||||
|
|
||||||
<ul>
|
<ul>
|
||||||
<li>Avoid recursion because of concern about C++'s limited guaranteed
|
<li>Avoid recursion because of concern about C++'s limited
|
||||||
recursion depth (17).</li>
|
guaranteed recursion depth (17).</li>
|
||||||
<li>Avoid macros on general principles.</li>
|
<li>Avoid macros on general principles.</li>
|
||||||
<li>Try to keep the design as simple as possible.</li>
|
<li>Try to keep the design as simple as possible.</li>
|
||||||
</ul>
|
</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
|
<p>If the number of bits required is known beforehand, it may be more
|
||||||
Dawes</a>. He thanks to <a href="../../people/valentin_bonnard.htm"> Valentin Bonnard</a> and
|
appropriate to use the types supplied in <cite><a
|
||||||
<a href="../../people/kevlin_henney.htm"> Kevlin Henney</a> for sharing their designs for similar templates.</p>
|
href="../../boost/cstdint.hpp"><boost/cstdint.hpp></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>
|
<hr>
|
||||||
|
|
||||||
<p>Revised August 31, 1999</p>
|
<p>Revised May 20, 2001</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 "as is" without express or implied warranty,
|
|
||||||
and with no claim as to its suitability for any purpose.</p>
|
|
||||||
|
|
||||||
<p></p>
|
|
||||||
|
|
||||||
<p> </p>
|
|
||||||
|
|
||||||
|
<p>© 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 "as
|
||||||
|
is" without express or implied warranty, and with no claim as to
|
||||||
|
its suitability for any purpose.</p>
|
||||||
</body>
|
</body>
|
||||||
|
|
||||||
</html>
|
</html>
|
||||||
|
|||||||
512
integer_test.cpp
512
integer_test.cpp
@ -9,313 +9,247 @@
|
|||||||
// See http://www.boost.org for most recent version including documentation.
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
|
||||||
// Revision History
|
// 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)
|
// 10 Mar 01 Boost Test Library now used for tests (Beman Dawes)
|
||||||
// 31 Aug 99 Initial version
|
// 31 Aug 99 Initial version
|
||||||
|
|
||||||
#include <iostream>
|
|
||||||
#include <boost/integer.hpp>
|
|
||||||
|
|
||||||
#define BOOST_INCLUDE_MAIN
|
#define BOOST_INCLUDE_MAIN
|
||||||
#include <boost/test/test_tools.hpp>
|
#include <boost/test/test_tools.hpp> // for main, BOOST_TEST
|
||||||
|
|
||||||
namespace
|
#include <boost/config.hpp> // for BOOST_NO_USING_TEMPLATE
|
||||||
{
|
#include <boost/cstdlib.hpp> // for boost::exit_success
|
||||||
void test( long ) { std::cout << "long\n"; }
|
#include <boost/integer.hpp> // for boost::int_t, boost::uint_t
|
||||||
void test( int ) { std::cout << "int\n"; }
|
|
||||||
void test( short ) { std::cout << "short\n"; }
|
|
||||||
void test( signed char ) { std::cout << "signed char\n"; }
|
|
||||||
void test( unsigned long ) { std::cout << "unsigned long\n"; }
|
|
||||||
void test( unsigned int ) { std::cout << "unsigned int\n"; }
|
|
||||||
void test( unsigned short ) { std::cout << "unsigned short\n"; }
|
|
||||||
void test( unsigned char ) { std::cout << "unsigned char\n"; }
|
|
||||||
} // unnamed namespace
|
|
||||||
|
|
||||||
// just to prove it works, specialize int_fast_t<short> to yield long
|
#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
|
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
|
#ifndef BOOST_NO_USING_TEMPLATE
|
||||||
using boost::int_t;
|
using boost::int_t;
|
||||||
using boost::uint_t;
|
using boost::uint_t;
|
||||||
|
using boost::int_max_value_t;
|
||||||
|
using boost::int_min_value_t;
|
||||||
|
using boost::uint_value_t;
|
||||||
#else
|
#else
|
||||||
using namespace boost;
|
using namespace boost;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef BOOST_SHOW_TYPES
|
SHOW_TYPES( int_t, least );
|
||||||
std::cout << 32 << ' '; test( int_t<32>::least() );
|
SHOW_TYPES( int_t, fast );
|
||||||
std::cout << 31 << ' '; test( int_t<31>::least() );
|
SHOW_TYPES( uint_t, least );
|
||||||
std::cout << 30 << ' '; test( int_t<30>::least() );
|
SHOW_TYPES( uint_t, fast );
|
||||||
std::cout << 29 << ' '; test( int_t<29>::least() );
|
SHOW_POS_SHIFTED_TYPES( int_max_value_t, least );
|
||||||
std::cout << 28 << ' '; test( int_t<28>::least() );
|
SHOW_POS_SHIFTED_TYPES( int_max_value_t, fast );
|
||||||
std::cout << 27 << ' '; test( int_t<27>::least() );
|
SHOW_NEG_SHIFTED_TYPES( int_min_value_t, least );
|
||||||
std::cout << 26 << ' '; test( int_t<26>::least() );
|
SHOW_NEG_SHIFTED_TYPES( int_min_value_t, fast );
|
||||||
std::cout << 25 << ' '; test( int_t<25>::least() );
|
SHOW_SHIFTED_TYPES( uint_value_t, least );
|
||||||
std::cout << 24 << ' '; test( int_t<24>::least() );
|
SHOW_SHIFTED_TYPES( uint_value_t, fast );
|
||||||
std::cout << 23 << ' '; test( int_t<23>::least() );
|
|
||||||
std::cout << 22 << ' '; test( int_t<22>::least() );
|
|
||||||
std::cout << 21 << ' '; test( int_t<21>::least() );
|
|
||||||
std::cout << 20 << ' '; test( int_t<20>::least() );
|
|
||||||
std::cout << 19 << ' '; test( int_t<19>::least() );
|
|
||||||
std::cout << 18 << ' '; test( int_t<18>::least() );
|
|
||||||
std::cout << 17 << ' '; test( int_t<17>::least() );
|
|
||||||
std::cout << 16 << ' '; test( int_t<16>::least() );
|
|
||||||
std::cout << 15 << ' '; test( int_t<15>::least() );
|
|
||||||
std::cout << 14 << ' '; test( int_t<14>::least() );
|
|
||||||
std::cout << 13 << ' '; test( int_t<13>::least() );
|
|
||||||
std::cout << 12 << ' '; test( int_t<12>::least() );
|
|
||||||
std::cout << 11 << ' '; test( int_t<11>::least() );
|
|
||||||
std::cout << 10 << ' '; test( int_t<10>::least() );
|
|
||||||
std::cout << 9 << ' '; test( int_t<9>::least() );
|
|
||||||
std::cout << 8 << ' '; test( int_t<8>::least() );
|
|
||||||
std::cout << 7 << ' '; test( int_t<7>::least() );
|
|
||||||
std::cout << 6 << ' '; test( int_t<6>::least() );
|
|
||||||
std::cout << 5 << ' '; test( int_t<5>::least() );
|
|
||||||
std::cout << 4 << ' '; test( int_t<4>::least() );
|
|
||||||
std::cout << 3 << ' '; test( int_t<3>::least() );
|
|
||||||
std::cout << 2 << ' '; test( int_t<2>::least() );
|
|
||||||
std::cout << 1 << ' '; test( int_t<1>::least() );
|
|
||||||
std::cout << 0 << ' '; test( int_t<0>::least() );
|
|
||||||
std::cout << 32 << ' '; test( int_t<32>::fast() );
|
|
||||||
std::cout << 31 << ' '; test( int_t<31>::fast() );
|
|
||||||
std::cout << 30 << ' '; test( int_t<30>::fast() );
|
|
||||||
std::cout << 29 << ' '; test( int_t<29>::fast() );
|
|
||||||
std::cout << 28 << ' '; test( int_t<28>::fast() );
|
|
||||||
std::cout << 27 << ' '; test( int_t<27>::fast() );
|
|
||||||
std::cout << 26 << ' '; test( int_t<26>::fast() );
|
|
||||||
std::cout << 25 << ' '; test( int_t<25>::fast() );
|
|
||||||
std::cout << 24 << ' '; test( int_t<24>::fast() );
|
|
||||||
std::cout << 23 << ' '; test( int_t<23>::fast() );
|
|
||||||
std::cout << 22 << ' '; test( int_t<22>::fast() );
|
|
||||||
std::cout << 21 << ' '; test( int_t<21>::fast() );
|
|
||||||
std::cout << 20 << ' '; test( int_t<20>::fast() );
|
|
||||||
std::cout << 19 << ' '; test( int_t<19>::fast() );
|
|
||||||
std::cout << 18 << ' '; test( int_t<18>::fast() );
|
|
||||||
std::cout << 17 << ' '; test( int_t<17>::fast() );
|
|
||||||
std::cout << 16 << ' '; test( int_t<16>::fast() );
|
|
||||||
std::cout << 15 << ' '; test( int_t<15>::fast() );
|
|
||||||
std::cout << 14 << ' '; test( int_t<14>::fast() );
|
|
||||||
std::cout << 13 << ' '; test( int_t<13>::fast() );
|
|
||||||
std::cout << 12 << ' '; test( int_t<12>::fast() );
|
|
||||||
std::cout << 11 << ' '; test( int_t<11>::fast() );
|
|
||||||
std::cout << 10 << ' '; test( int_t<10>::fast() );
|
|
||||||
std::cout << 9 << ' '; test( int_t<9>::fast() );
|
|
||||||
std::cout << 8 << ' '; test( int_t<8>::fast() );
|
|
||||||
std::cout << 7 << ' '; test( int_t<7>::fast() );
|
|
||||||
std::cout << 6 << ' '; test( int_t<6>::fast() );
|
|
||||||
std::cout << 5 << ' '; test( int_t<5>::fast() );
|
|
||||||
std::cout << 4 << ' '; test( int_t<4>::fast() );
|
|
||||||
std::cout << 3 << ' '; test( int_t<3>::fast() );
|
|
||||||
std::cout << 2 << ' '; test( int_t<2>::fast() );
|
|
||||||
std::cout << 1 << ' '; test( int_t<1>::fast() );
|
|
||||||
std::cout << 0 << ' '; test( int_t<0>::fast() );
|
|
||||||
std::cout << 32 << ' '; test( uint_t<32>::least() );
|
|
||||||
std::cout << 31 << ' '; test( uint_t<31>::least() );
|
|
||||||
std::cout << 30 << ' '; test( uint_t<30>::least() );
|
|
||||||
std::cout << 29 << ' '; test( uint_t<29>::least() );
|
|
||||||
std::cout << 28 << ' '; test( uint_t<28>::least() );
|
|
||||||
std::cout << 27 << ' '; test( uint_t<27>::least() );
|
|
||||||
std::cout << 26 << ' '; test( uint_t<26>::least() );
|
|
||||||
std::cout << 25 << ' '; test( uint_t<25>::least() );
|
|
||||||
std::cout << 24 << ' '; test( uint_t<24>::least() );
|
|
||||||
std::cout << 23 << ' '; test( uint_t<23>::least() );
|
|
||||||
std::cout << 22 << ' '; test( uint_t<22>::least() );
|
|
||||||
std::cout << 21 << ' '; test( uint_t<21>::least() );
|
|
||||||
std::cout << 20 << ' '; test( uint_t<20>::least() );
|
|
||||||
std::cout << 19 << ' '; test( uint_t<19>::least() );
|
|
||||||
std::cout << 18 << ' '; test( uint_t<18>::least() );
|
|
||||||
std::cout << 17 << ' '; test( uint_t<17>::least() );
|
|
||||||
std::cout << 16 << ' '; test( uint_t<16>::least() );
|
|
||||||
std::cout << 15 << ' '; test( uint_t<15>::least() );
|
|
||||||
std::cout << 14 << ' '; test( uint_t<14>::least() );
|
|
||||||
std::cout << 13 << ' '; test( uint_t<13>::least() );
|
|
||||||
std::cout << 12 << ' '; test( uint_t<12>::least() );
|
|
||||||
std::cout << 11 << ' '; test( uint_t<11>::least() );
|
|
||||||
std::cout << 10 << ' '; test( uint_t<10>::least() );
|
|
||||||
std::cout << 9 << ' '; test( uint_t<9>::least() );
|
|
||||||
std::cout << 8 << ' '; test( uint_t<8>::least() );
|
|
||||||
std::cout << 7 << ' '; test( uint_t<7>::least() );
|
|
||||||
std::cout << 6 << ' '; test( uint_t<6>::least() );
|
|
||||||
std::cout << 5 << ' '; test( uint_t<5>::least() );
|
|
||||||
std::cout << 4 << ' '; test( uint_t<4>::least() );
|
|
||||||
std::cout << 3 << ' '; test( uint_t<3>::least() );
|
|
||||||
std::cout << 2 << ' '; test( uint_t<2>::least() );
|
|
||||||
std::cout << 1 << ' '; test( uint_t<1>::least() );
|
|
||||||
std::cout << 0 << ' '; test( uint_t<0>::least() );
|
|
||||||
std::cout << 32 << ' '; test( uint_t<32>::fast() );
|
|
||||||
std::cout << 31 << ' '; test( uint_t<31>::fast() );
|
|
||||||
std::cout << 30 << ' '; test( uint_t<30>::fast() );
|
|
||||||
std::cout << 29 << ' '; test( uint_t<29>::fast() );
|
|
||||||
std::cout << 28 << ' '; test( uint_t<28>::fast() );
|
|
||||||
std::cout << 27 << ' '; test( uint_t<27>::fast() );
|
|
||||||
std::cout << 26 << ' '; test( uint_t<26>::fast() );
|
|
||||||
std::cout << 25 << ' '; test( uint_t<25>::fast() );
|
|
||||||
std::cout << 24 << ' '; test( uint_t<24>::fast() );
|
|
||||||
std::cout << 23 << ' '; test( uint_t<23>::fast() );
|
|
||||||
std::cout << 22 << ' '; test( uint_t<22>::fast() );
|
|
||||||
std::cout << 21 << ' '; test( uint_t<21>::fast() );
|
|
||||||
std::cout << 20 << ' '; test( uint_t<20>::fast() );
|
|
||||||
std::cout << 19 << ' '; test( uint_t<19>::fast() );
|
|
||||||
std::cout << 18 << ' '; test( uint_t<18>::fast() );
|
|
||||||
std::cout << 17 << ' '; test( uint_t<17>::fast() );
|
|
||||||
std::cout << 16 << ' '; test( uint_t<16>::fast() );
|
|
||||||
std::cout << 15 << ' '; test( uint_t<15>::fast() );
|
|
||||||
std::cout << 14 << ' '; test( uint_t<14>::fast() );
|
|
||||||
std::cout << 13 << ' '; test( uint_t<13>::fast() );
|
|
||||||
std::cout << 12 << ' '; test( uint_t<12>::fast() );
|
|
||||||
std::cout << 11 << ' '; test( uint_t<11>::fast() );
|
|
||||||
std::cout << 10 << ' '; test( uint_t<10>::fast() );
|
|
||||||
std::cout << 9 << ' '; test( uint_t<9>::fast() );
|
|
||||||
std::cout << 8 << ' '; test( uint_t<8>::fast() );
|
|
||||||
std::cout << 7 << ' '; test( uint_t<7>::fast() );
|
|
||||||
std::cout << 6 << ' '; test( uint_t<6>::fast() );
|
|
||||||
std::cout << 5 << ' '; test( uint_t<5>::fast() );
|
|
||||||
std::cout << 4 << ' '; test( uint_t<4>::fast() );
|
|
||||||
std::cout << 3 << ' '; test( uint_t<3>::fast() );
|
|
||||||
std::cout << 2 << ' '; test( uint_t<2>::fast() );
|
|
||||||
std::cout << 1 << ' '; test( uint_t<1>::fast() );
|
|
||||||
std::cout << 0 << ' '; test( uint_t<0>::fast() );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
long v = 0x7FFFFFFF;
|
PRIVATE_FIT_TESTS( int_t, least, long, LONG_MAX );
|
||||||
BOOST_TEST( int_t<32>::least(v) == v ); v >>= 1;
|
PRIVATE_FIT_TESTS( int_t, fast, long, LONG_MAX );
|
||||||
BOOST_TEST( int_t<31>::least(v) == v ); v >>= 1;
|
PRIVATE_FIT_TESTS( uint_t, least, unsigned long, ULONG_MAX );
|
||||||
BOOST_TEST( int_t<30>::least(v) == v ); v >>= 1;
|
PRIVATE_FIT_TESTS( uint_t, fast, unsigned long, ULONG_MAX );
|
||||||
BOOST_TEST( int_t<29>::least(v) == v ); v >>= 1;
|
PRIVATE_POS_FIT_TESTS( int_max_value_t, least, long, LONG_MAX );
|
||||||
BOOST_TEST( int_t<28>::least(v) == v ); v >>= 1;
|
PRIVATE_POS_FIT_TESTS( int_max_value_t, fast, long, LONG_MAX );
|
||||||
BOOST_TEST( int_t<27>::least(v) == v ); v >>= 1;
|
PRIVATE_NEG_FIT_TESTS( int_min_value_t, least, long, LONG_MIN );
|
||||||
BOOST_TEST( int_t<26>::least(v) == v ); v >>= 1;
|
PRIVATE_NEG_FIT_TESTS( int_min_value_t, fast, long, LONG_MIN );
|
||||||
BOOST_TEST( int_t<25>::least(v) == v ); v >>= 1;
|
PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, least, unsigned long, ULONG_MAX );
|
||||||
BOOST_TEST( int_t<24>::least(v) == v ); v >>= 1;
|
PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, fast, unsigned long, ULONG_MAX );
|
||||||
BOOST_TEST( int_t<23>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<22>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<21>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<20>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<19>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<18>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<17>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<16>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<15>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<14>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<13>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<12>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<11>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<10>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<9>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<8>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<7>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<6>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<5>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<4>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<3>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<2>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<1>::least(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<0>::least(v) == v );
|
|
||||||
v = 0x7FFFFFFF;
|
|
||||||
BOOST_TEST( int_t<32>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<31>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<30>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<29>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<28>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<27>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<26>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<25>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<24>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<23>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<22>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<21>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<20>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<19>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<18>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<17>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<16>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<15>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<14>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<13>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<12>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<11>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<10>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<9>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<8>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<7>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<6>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<5>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<4>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<3>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<2>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<1>::fast(v) == v ); v >>= 1;
|
|
||||||
BOOST_TEST( int_t<0>::fast(v) == v );
|
|
||||||
unsigned long u = 0xFFFFFFFF;
|
|
||||||
BOOST_TEST( uint_t<32>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<31>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<30>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<29>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<28>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<27>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<26>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<25>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<24>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<23>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<22>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<21>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<20>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<19>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<18>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<17>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<16>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<15>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<14>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<13>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<11>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<12>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<10>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<9>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<8>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<7>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<6>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<5>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<4>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<3>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<2>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<1>::least(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<0>::least(u) == u );
|
|
||||||
u = 0xFFFFFFFF;
|
|
||||||
BOOST_TEST( uint_t<32>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<31>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<30>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<29>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<28>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<27>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<26>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<25>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<24>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<23>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<22>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<21>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<20>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<19>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<18>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<17>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<16>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<15>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<14>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<13>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<12>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<11>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<10>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<9>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<8>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<7>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<6>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<5>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<4>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<3>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<2>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<1>::fast(u) == u ); u >>= 1;
|
|
||||||
BOOST_TEST( uint_t<0>::fast(u) == u );
|
|
||||||
|
|
||||||
return 0;
|
return boost::exit_success;
|
||||||
}
|
}
|
||||||
|
|||||||
Reference in New Issue
Block a user