mirror of
https://github.com/boostorg/integer.git
synced 2025-07-02 23:36:55 +02:00
Compare commits
1 Commits
boost-1.22
...
boost-1.19
| Author | SHA1 | Date | |
|---|---|---|---|
| 770b8c8322 |
@ -69,7 +69,7 @@ representing any value of any signed integer type.</p>
|
||||
capable of representing any value of any unsigned integer type.</p>
|
||||
<p>These types are required.</p>
|
||||
<hr>
|
||||
<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->10 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14373" -->
|
||||
<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->14 Nov 2000<!--webbot bot="Timestamp" endspan i-checksum="15241" -->
|
||||
</p>
|
||||
<p> </p>
|
||||
|
||||
|
||||
@ -9,8 +9,6 @@
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
// Revision History
|
||||
// 16 Apr 01 check LONGLONG_MAX when looking for "long long" (Jens Maurer)
|
||||
// 23 Jan 01 prefer "long" over "int" for int32_t and intmax_t (Jens Maurer)
|
||||
// 12 Nov 00 Merged <boost/stdint.h> (Jens Maurer)
|
||||
// 23 Sep 00 Added INTXX_C macro support (John Maddock).
|
||||
// 22 Sep 00 Better 64-bit support (John Maddock)
|
||||
@ -26,17 +24,7 @@
|
||||
|
||||
#ifdef BOOST_SYSTEM_HAS_STDINT_H
|
||||
|
||||
// The following #include is an implementation artifact; not part of interface.
|
||||
# ifdef __hpux
|
||||
// HP-UX has a nice <stdint.h> in a non-standard location
|
||||
# include <sys/_inttypes.h>
|
||||
# ifdef __STDC_32_MODE__
|
||||
// this is triggered with GCC, because it defines __cplusplus < 199707L
|
||||
# define BOOST_NO_INT64_T
|
||||
# endif
|
||||
# else
|
||||
# include <stdint.h>
|
||||
# endif
|
||||
# include <stdint.h> // implementation artifact; not part of interface
|
||||
|
||||
namespace boost
|
||||
{
|
||||
@ -124,30 +112,29 @@ namespace boost
|
||||
|
||||
// 32-bit types -----------------------------------------------------------//
|
||||
|
||||
# if ULONG_MAX == 0xffffffff
|
||||
typedef long int32_t;
|
||||
typedef long int_least32_t;
|
||||
typedef long int_fast32_t;
|
||||
typedef unsigned long uint32_t;
|
||||
typedef unsigned long uint_least32_t;
|
||||
typedef unsigned long uint_fast32_t;
|
||||
# elif UINT_MAX == 0xffffffff
|
||||
# if UINT_MAX == 0xffffffff
|
||||
typedef int int32_t;
|
||||
typedef int int_least32_t;
|
||||
typedef int int_fast32_t;
|
||||
typedef unsigned int uint32_t;
|
||||
typedef unsigned int uint_least32_t;
|
||||
typedef unsigned int uint_fast32_t;
|
||||
# elif ULONG_MAX == 0xffffffff
|
||||
typedef long int32_t;
|
||||
typedef long int_least32_t;
|
||||
typedef long int_fast32_t;
|
||||
typedef unsigned long uint32_t;
|
||||
typedef unsigned long uint_least32_t;
|
||||
typedef unsigned long uint_fast32_t;
|
||||
# else
|
||||
# error defaults not correct; you must hand modify boost/cstdint.hpp
|
||||
# endif
|
||||
|
||||
// 64-bit types + intmax_t and uintmax_t ----------------------------------//
|
||||
|
||||
# if !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \
|
||||
(!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
|
||||
(defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
|
||||
# if (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615U) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615U) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615U)
|
||||
# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) && !(defined(_WIN32) && defined(__GNUC__))
|
||||
# if(defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615) || \
|
||||
(defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615)
|
||||
// 2**64 - 1
|
||||
typedef long long intmax_t;
|
||||
typedef unsigned long long uintmax_t;
|
||||
@ -265,11 +252,9 @@ Added 23rd September (John Maddock).
|
||||
|
||||
// 64-bit types + intmax_t and uintmax_t ----------------------------------//
|
||||
|
||||
# if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)
|
||||
// HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
|
||||
# if (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615U) || \
|
||||
(defined(ULONG_LONG_MAX) && (defined(__hpux) || ULONG_LONG_MAX == 18446744073709551615U)) || \
|
||||
(defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615U)
|
||||
# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) && !(defined(_WIN32) && defined(__GNUC__))
|
||||
# if(defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615) || \
|
||||
(defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615)
|
||||
# define INT64_C(value) value##LL
|
||||
# define UINT64_C(value) value##uLL
|
||||
# else
|
||||
@ -312,5 +297,3 @@ Added 23rd September (John Maddock).
|
||||
# undef UINTMAX_C
|
||||
|
||||
#endif // __STDC_CONSTANT_MACROS_DEFINED etc.
|
||||
|
||||
|
||||
|
||||
@ -9,14 +9,13 @@
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
// Revision History
|
||||
// 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
|
||||
|
||||
#ifndef BOOST_INTEGER_HPP
|
||||
#define BOOST_INTEGER_HPP
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
#include <limits>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
@ -24,7 +23,6 @@ namespace boost
|
||||
// Helper templates ------------------------------------------------------//
|
||||
|
||||
// fast integers from least integers
|
||||
// int_fast_t<> works correctly for unsigned too, in spite of the name.
|
||||
template< typename LeastInt >
|
||||
struct int_fast_t { typedef LeastInt fast; }; // imps may specialize
|
||||
|
||||
@ -33,7 +31,6 @@ namespace boost
|
||||
|
||||
// specializatons: 1=long, 2=int, 3=short, 4=signed char,
|
||||
// 6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned long
|
||||
// no specializations for 0 and 5: requests for a type > long are in error
|
||||
template<> struct int_least_helper<1> { typedef long least; };
|
||||
template<> struct int_least_helper<2> { typedef int least; };
|
||||
template<> struct int_least_helper<3> { typedef short least; };
|
||||
@ -56,7 +53,7 @@ namespace boost
|
||||
(Bits-1 <= std::numeric_limits<short>::digits) +
|
||||
(Bits-1 <= std::numeric_limits<signed char>::digits)
|
||||
>::least least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
typedef int_fast_t<least>::fast fast;
|
||||
};
|
||||
|
||||
// unsigned
|
||||
@ -71,8 +68,7 @@ namespace boost
|
||||
(Bits <= std::numeric_limits<unsigned short>::digits) +
|
||||
(Bits <= std::numeric_limits<unsigned char>::digits)
|
||||
>::least least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
// int_fast_t<> works correctly for unsigned too, in spite of the name.
|
||||
typedef int_fast_t<least>::fast fast;
|
||||
};
|
||||
|
||||
// The same dispatching technique can be used to select types based on
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
*
|
||||
* Copyright Jens Maurer 2000
|
||||
* Permission to use, copy, modify, sell, and distribute this software
|
||||
* is hereby granted without fee provided that the above copyright notice
|
||||
* is hereby granted without free provided that the above copyright notice
|
||||
* appears in all copies and that both that copyright notice and this
|
||||
* permission notice appear in supporting documentation,
|
||||
*
|
||||
@ -18,14 +18,11 @@
|
||||
#ifndef BOOST_INTEGER_TRAITS_HPP
|
||||
#define BOOST_INTEGER_TRAITS_HPP
|
||||
|
||||
#include <limits>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
|
||||
// These are an implementation detail and not part of the interface
|
||||
// This is an implementation detail and not part of the interface
|
||||
#include <limits.h>
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
#include <wchar.h>
|
||||
#endif
|
||||
|
||||
|
||||
namespace boost {
|
||||
@ -33,7 +30,11 @@ template<class T>
|
||||
class integer_traits : public std::numeric_limits<T>
|
||||
{
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, is_integral = false);
|
||||
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||
static const bool is_integral = false;
|
||||
#else
|
||||
enum { is_integral = false };
|
||||
#endif
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
@ -41,20 +42,18 @@ template<class T, T min_val, T max_val>
|
||||
class integer_traits_base
|
||||
{
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, is_integral = true);
|
||||
BOOST_STATIC_CONSTANT(T, const_min = min_val);
|
||||
BOOST_STATIC_CONSTANT(T, const_max = max_val);
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||
// The definition is required even for integral static constants
|
||||
template<class T, T min_val, T max_val>
|
||||
const T integer_traits_base<T, min_val, max_val>::const_min;
|
||||
|
||||
template<class T, T min_val, T max_val>
|
||||
const T integer_traits_base<T, min_val, max_val>::const_max;
|
||||
static const bool is_integral = true;
|
||||
static const T const_min = min_val;
|
||||
static const T const_max = max_val;
|
||||
#else
|
||||
enum {
|
||||
is_integral = true,
|
||||
const_min = min_val,
|
||||
const_max = max_val
|
||||
};
|
||||
#endif
|
||||
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
template<>
|
||||
@ -81,25 +80,7 @@ class integer_traits<unsigned char>
|
||||
public detail::integer_traits_base<unsigned char, 0, UCHAR_MAX>
|
||||
{ };
|
||||
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
template<>
|
||||
class integer_traits<wchar_t>
|
||||
: public std::numeric_limits<wchar_t>,
|
||||
#if defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
|
||||
// No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned:
|
||||
public detail::integer_traits_base<wchar_t, 0, 0xffff>
|
||||
#elif defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400)
|
||||
// SGI MIPSpro with native library doesn't have them, either
|
||||
public detail::integer_traits_base<wchar_t, INT_MIN, INT_MAX>
|
||||
#elif defined(__hpux) && defined(__GNUC__) && !defined(__SGI_STL_PORT)
|
||||
// GCC 2.95.2 doesn't have them on HP-UX, either
|
||||
// (also, std::numeric_limits<wchar_t> appears to return the wrong values)
|
||||
public detail::integer_traits_base<wchar_t, 0, UINT_MAX>
|
||||
#else
|
||||
public detail::integer_traits_base<wchar_t, WCHAR_MIN, WCHAR_MAX>
|
||||
#endif
|
||||
{ };
|
||||
#endif // BOOST_NO_INTRINSIC_WCHAR_T
|
||||
// What about wchar_t ?
|
||||
|
||||
template<>
|
||||
class integer_traits<short>
|
||||
@ -159,20 +140,8 @@ class integer_traits<unsigned long long>
|
||||
: public std::numeric_limits<unsigned long long>,
|
||||
public detail::integer_traits_base<unsigned long long, 0, ULONG_LONG_MAX>
|
||||
{ };
|
||||
#elif defined(ULONGLONG_MAX)
|
||||
template<>
|
||||
class integer_traits<long long>
|
||||
: public std::numeric_limits<long long>,
|
||||
public detail::integer_traits_base<long long, LONGLONG_MIN, LONGLONG_MAX>
|
||||
{ };
|
||||
template<>
|
||||
class integer_traits<unsigned long long>
|
||||
: public std::numeric_limits<unsigned long long>,
|
||||
public detail::integer_traits_base<unsigned long long, 0, ULONGLONG_MAX>
|
||||
{ };
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif /* BOOST_INTEGER_TRAITS_HPP */
|
||||
|
||||
|
||||
@ -90,7 +90,7 @@ instead.
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->10 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14373" -->
|
||||
<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->14 Nov 2000<!--webbot bot="Timestamp" endspan i-checksum="15241" -->
|
||||
</p>
|
||||
|
||||
</body>
|
||||
|
||||
@ -34,7 +34,6 @@ appropriate to use the types supplied in <code><a href="../../boost/cstdint.hpp"
|
||||
<pre>namespace boost
|
||||
{
|
||||
// fast integers from least integers
|
||||
// int_fast_t<> works correctly for unsigned too, in spite of the name.
|
||||
template< typename LeastInt > // Required: LeastInt is integral type, not bool
|
||||
struct int_fast_t { typedef LeastInt fast; }; // implementations may specialize
|
||||
|
||||
@ -52,7 +51,6 @@ appropriate to use the types supplied in <code><a href="../../boost/cstdint.hpp"
|
||||
{
|
||||
typedef <i>implementation-supplied</i> least;
|
||||
typedef int_fast_t<least>::fast fast;
|
||||
// int_fast_t<> works correctly for unsigned too, in spite of the name.
|
||||
};
|
||||
} // namespace boost
|
||||
</pre>
|
||||
|
||||
155
integer_test.cpp
155
integer_test.cpp
@ -9,14 +9,15 @@
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
// Revision History
|
||||
// 10 Mar 01 Boost Test Library now used for tests (Beman Dawes)
|
||||
// 31 Aug 99 Initial version
|
||||
|
||||
// This program is misnamed in that it is really a demonstration rather than
|
||||
// a test. It doesn't detect failure, so isn't worthy of the name "test".
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/integer.hpp>
|
||||
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
using namespace boost; // not the best practice, but useful for testing
|
||||
|
||||
namespace
|
||||
{
|
||||
@ -36,12 +37,8 @@ namespace boost
|
||||
template<> struct int_fast_t<short> { typedef long fast; };
|
||||
}
|
||||
|
||||
int test_main(int,char**)
|
||||
int main()
|
||||
{
|
||||
using boost::int_t;
|
||||
using boost::uint_t;
|
||||
|
||||
#ifdef BOOST_SHOW_TYPES
|
||||
std::cout << 32 << ' '; test( int_t<32>::least() );
|
||||
std::cout << 31 << ' '; test( int_t<31>::least() );
|
||||
std::cout << 30 << ' '; test( int_t<30>::least() );
|
||||
@ -173,145 +170,7 @@ int test_main(int,char**)
|
||||
std::cout << 3 << ' '; test( uint_t<3>::fast() );
|
||||
std::cout << 2 << ' '; test( uint_t<2>::fast() );
|
||||
std::cout << 1 << ' '; test( uint_t<1>::fast() );
|
||||
std::cout << 0 << ' '; test( uint_t<0>::fast() );
|
||||
#endif
|
||||
|
||||
long v = 0x7FFFFFFF;
|
||||
BOOST_TEST( int_t<32>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<31>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<30>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<29>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<28>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<27>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<26>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<25>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<24>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<23>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<22>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<21>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<20>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<19>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<18>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<17>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<16>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<15>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<14>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<13>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<12>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<11>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<10>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<9>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<8>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<7>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<6>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<5>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<4>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<3>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<2>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<1>::least(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<0>::least(v) == v );
|
||||
v = 0x7FFFFFFF;
|
||||
BOOST_TEST( int_t<32>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<31>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<30>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<29>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<28>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<27>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<26>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<25>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<24>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<23>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<22>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<21>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<20>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<19>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<18>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<17>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<16>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<15>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<14>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<13>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<12>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<11>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<10>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<9>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<8>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<7>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<6>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<5>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<4>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<3>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<2>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<1>::fast(v) == v ); v >>= 1;
|
||||
BOOST_TEST( int_t<0>::fast(v) == v );
|
||||
unsigned long u = 0xFFFFFFFF;
|
||||
BOOST_TEST( uint_t<32>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<31>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<30>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<29>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<28>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<27>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<26>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<25>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<24>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<23>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<22>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<21>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<20>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<19>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<18>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<17>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<16>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<15>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<14>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<13>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<11>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<12>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<10>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<9>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<8>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<7>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<6>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<5>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<4>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<3>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<2>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<1>::least(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<0>::least(u) == u );
|
||||
u = 0xFFFFFFFF;
|
||||
BOOST_TEST( uint_t<32>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<31>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<30>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<29>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<28>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<27>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<26>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<25>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<24>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<23>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<22>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<21>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<20>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<19>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<18>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<17>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<16>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<15>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<14>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<13>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<12>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<11>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<10>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<9>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<8>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<7>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<6>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<5>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<4>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<3>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<2>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<1>::fast(u) == u ); u >>= 1;
|
||||
BOOST_TEST( uint_t<0>::fast(u) == u );
|
||||
|
||||
std::cout << 0 << ' '; test( uint_t<0>::fast() );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -18,12 +18,15 @@
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <cassert>
|
||||
#include <boost/integer_traits.hpp>
|
||||
// use int64_t instead of long long for better portability
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
#ifdef NDEBUG
|
||||
#error This test relies on assert() and thus makes no sense with NDEBUG defined
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* General portability note:
|
||||
@ -43,14 +46,14 @@ void runtest(const char * type, T)
|
||||
<< "; min is " << traits::min()
|
||||
<< ", max is " << traits::max()
|
||||
<< std::endl;
|
||||
BOOST_TEST(traits::is_specialized);
|
||||
BOOST_TEST(traits::is_integer);
|
||||
BOOST_TEST(traits::is_integral);
|
||||
BOOST_TEST(traits::const_min == traits::min());
|
||||
BOOST_TEST(traits::const_max == traits::max());
|
||||
assert(traits::is_specialized);
|
||||
assert(traits::is_integer);
|
||||
assert(traits::is_integral);
|
||||
assert(traits::const_min == traits::min());
|
||||
assert(traits::const_max == traits::max());
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
int main()
|
||||
{
|
||||
runtest("bool", bool());
|
||||
runtest("char", char());
|
||||
@ -58,7 +61,6 @@ int test_main(int, char*[])
|
||||
runtest("signed char", signed_char());
|
||||
typedef unsigned char unsigned_char;
|
||||
runtest("unsigned char", unsigned_char());
|
||||
runtest("wchar_t", wchar_t());
|
||||
runtest("short", short());
|
||||
typedef unsigned short unsigned_short;
|
||||
runtest("unsigned short", unsigned_short());
|
||||
@ -68,17 +70,13 @@ int test_main(int, char*[])
|
||||
runtest("long", long());
|
||||
typedef unsigned long unsigned_long;
|
||||
runtest("unsigned long", unsigned_long());
|
||||
#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_MSVC) && !defined(__BORLANDC__) && !defined(__BEOS__)
|
||||
#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_MSVC) && !defined(__BORLANDC__)
|
||||
//
|
||||
// MS/Borland compilers can't support 64-bit member constants
|
||||
// BeOS doesn't have specialisations for long long in SGI's <limits> header.
|
||||
runtest("int64_t (possibly long long)", boost::int64_t());
|
||||
runtest("uint64_t (possibly unsigned long long)", boost::uint64_t());
|
||||
#else
|
||||
std::cout << "Skipped int64_t and uint64_t" << std::endl;
|
||||
#endif
|
||||
// Some compilers don't pay attention to std:3.6.1/5 and issue a
|
||||
// warning here if "return 0;" is omitted.
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user