From 3bb567ad9dbc49b9bd839e182bdf494b95f84c34 Mon Sep 17 00:00:00 2001 From: Dave Abrahams Date: Fri, 7 Dec 2001 13:19:38 +0000 Subject: [PATCH] initial checkin [SVN r11972] --- doc/integer_mask.html | 211 +++++++++++++++++++++++++++++++++++ doc/static_log2.html | 122 ++++++++++++++++++++ doc/static_min_max.html | 121 ++++++++++++++++++++ test/integer_mask_test.cpp | 112 +++++++++++++++++++ test/static_log2_test.cpp | 151 +++++++++++++++++++++++++ test/static_min_max_test.cpp | 94 ++++++++++++++++ 6 files changed, 811 insertions(+) create mode 100644 doc/integer_mask.html create mode 100644 doc/static_log2.html create mode 100644 doc/static_min_max.html create mode 100644 test/integer_mask_test.cpp create mode 100644 test/static_log2_test.cpp create mode 100644 test/static_min_max_test.cpp diff --git a/doc/integer_mask.html b/doc/integer_mask.html new file mode 100644 index 0000000..51ae8c9 --- /dev/null +++ b/doc/integer_mask.html @@ -0,0 +1,211 @@ + + + +Integer Bit Mask Templates + + + +

c++boost.gif (8819 bytes)Integer Bit Mask Templates

+ +

The class templates in <boost/integer/integer_mask.hpp> provide bit masks for a certain bit position or a contiguous-bit pack of a certain size. The types of the masking constants come from the integer type selection templates header.

+ +

Contents

+ + + +

Synopsis

+ +
+#include <cstddef>  // for std::size_t
+
+namespace boost
+{
+
+template < std::size_t Bit >
+struct high_bit_mask_t
+{
+    typedef implementation_supplied  least;
+    typedef implementation_supplied   fast;
+
+    static const least  high_bit = implementation_defined;
+    static const fast   high_bit_fast = implementation_defined;
+
+    static const std::size_t  bit_position = Bit;
+
+};
+
+template < std::size_t Bits >
+struct low_bits_mask_t
+{
+    typedef implementation_supplied  least;
+    typedef implementation_supplied   fast;
+
+    static const least  sig_bits = implementation_defined;
+    static const fast   sig_bits_fast = implementation_defined;
+
+    static const std::size_t  bit_count = Bits;
+
+};
+
+// Specializations for low_bits_mask_t exist for certain bit counts.
+
+}  // namespace boost
+
+ +

Single Bit-Mask Class Template

+ +

The boost::high_bit_mask_t class template provides +constants for bit masks representing the bit at a certain position. The +masks are equivalent to the value 2Bit, where +Bit is the template parameter. The bit position must be a +nonnegative number from zero to Max, where Max is one +less than the number of bits supported by the largest unsigned built-in +integral type. The following table describes the members of an +instantiation of high_bit_mask_t.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
Members of the boost::high_bit_mask_t Class + Template
MemberMeaning
leastThe smallest unsigned built-in type that supports the given + bit position.
fastThe quick-to-manipulate analog of least.
high_bitA least constant of the desired bit-masking + value.
high_bit_fastA fast analog of high_bit.
bit_positionThe value of the template parameter, in case its needed from + a renamed instantiation of the class template.
+ +

Group Bit-Mask Class Template

+ +

The boost::low_bits_mask_t class template provides +constants for bit masks representing the lowest bits of a certain +amount. The masks are equivalent to the value +(2Bits - 1), where Bits is the +template parameter. The bit amount must be a nonnegative number from +zero to Max, where Max is the number of bits supported +by the largest unsigned built-in integral type. The following table +describes the members of an instantiation of +low_bits_mask_t.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
Members of the boost::low_bits_mask_t Class + Template
MemberMeaning
leastThe smallest unsigned built-in type that supports the given + bit count.
fastThe quick-to-manipulate analog of least.
sig_bitsA least constant of the desired bit-masking + value.
sig_bits_fastA fast analog of sig_bits.
bit_countThe value of the template parameter, in case its needed from + a renamed instantiation of the class template.
+ +

Implementation Note
+When Bits is the exact size of a built-in unsigned type, +the implementation has to change to prevent undefined behavior. +Therefore, there are specializations of low_bits_mask_t at +those bit counts.

+ +

Example

+ +
+#include <boost/integer/integer_mask.hpp>
+
+//...
+
+int main()
+{
+    typedef boost::high_bit_mask_t<29>  mask1_type;
+    typedef boost::low_bits_mask_t<15>  mask2_type;
+
+    mask1_type::least  my_var1;
+    mask2_type::fast   my_var2;
+    //...
+
+    my_var1 |= mask1_type::high_bit;
+    my_var2 &= mask2_type::sig_bits_fast;
+
+    //...
+}
+
+ +

Demonstration Program

+ +

The program integer_mask_test.cpp +is a simplistic demonstration of the results from instantiating various +examples of the bit mask class templates.

+ +

Rationale

+ +

The class templates in this header are an extension of the integer type selection class templates. The new +class templates provide the same sized types, but also convienent masks +to use when extracting the highest or all the significant bits when the +containing built-in type contains more bits. This prevents +contaimination of values by the higher, unused bits.

+ +

Credits

+ +

The author of the Boost bit mask class templates is Daryle Walker.

+ +
+ +

Revised September 23, 2001

+ +

© Copyright Daryle Walker 2001. Permission to copy, use, +modify, sell and distribute this document is granted provided this +copyright notice appears in all copies. This document is provided +"as is" without express or implied warranty, and with no claim +as to its suitability for any purpose.

+ + diff --git a/doc/static_log2.html b/doc/static_log2.html new file mode 100644 index 0000000..d3daab2 --- /dev/null +++ b/doc/static_log2.html @@ -0,0 +1,122 @@ + + + +Binary Logarithm Template + + + +

c++boost.gif (8819 bytes)Binary Logarithm Template

+ +

The class template in <boost/integer/static_log2.hpp> determines the position of the highest bit in a given value. This facility is useful for solving generic programming problems.

+ +

Contents

+ + + +

Synopsis

+ +
+namespace boost
+{
+
+template < unsigned long Value >
+struct static_log2
+{
+    static const int  value = implementation_defined;
+};
+
+template < >
+struct static_log2< 0ul >
+{
+    // The logarithm of zero is undefined.
+};
+
+}  // namespace boost
+
+ +

Usage

+ +

The boost::static_log2 class template takes one template +parameter, a value of type unsigned long. The template +only defines one member, value, that returns the truncated +base-two logarithm of the template parameter.

+ +

Since the logarithm of zero, for any base, is undefined, there is a +specialization of static_log2 for a template parameter +of zero. This specialization has no members, so an attempt to use +the base-two logarithm of zero results in a compile-time error.

+ +

Example

+ +
+#include <boost/integer/static_log2.hpp>
+
+template < unsigned long Value >
+bool is_it_what()
+{
+    typedef boost::static_log2<Value>  lb_type;
+
+    int  temp = lb_type::value;
+    //...
+
+    return (temp % 2) != 0;
+}
+
+//...
+
+int main()
+{
+    bool  temp = is_it_what<2000>();
+    //...
+
+    #if 0
+    temp = is_it_what<0>();  // would give an error
+    #endif
+    //...
+
+    temp = is_it_what<24>();
+    //...
+}
+
+ +

Demonstration Program

+ +

The program static_log2_test.cpp +is a simplistic demonstration of the results from instantiating various +examples of the binary logarithm class template.

+ +

Rationale

+ +

The base-two (binary) logarithm, abbreviated lb, function +is occasionally used to give order-estimates of computer algorithms. +The truncated logarithm can be considered the highest power-of-two in a +value, which corresponds to the value's highest set bit (for binary +integers). Sometimes the highest-bit position could be used in generic +programming, which requires the position to be statically (i.e. +at compile-time) available.

+ +

Credits

+ +

The author of the Boost binary logarithm class template is Daryle Walker.

+ +
+ +

Revised October 1, 2001

+ +

© Copyright Daryle Walker 2001. Permission to copy, use, +modify, sell and distribute this document is granted provided this +copyright notice appears in all copies. This document is provided +"as is" without express or implied warranty, and with no claim +as to its suitability for any purpose.

+ + diff --git a/doc/static_min_max.html b/doc/static_min_max.html new file mode 100644 index 0000000..6f27b97 --- /dev/null +++ b/doc/static_min_max.html @@ -0,0 +1,121 @@ + + + +Compile-Time Extrema Templates + + + +

c++boost.gif (8819 bytes)Compile-Time Extrema +Templates

+ +

The class templates in <boost/integer/static_min_max.hpp> +provide a compile-time evaluation of the minimum or maximum of +two integers. These facilities are useful for generic programming problems.

+ +

Contents

+ + + +

Synopsis

+ +
+namespace boost
+{
+
+template < long Value1, long Value2 >
+    struct static_signed_min;
+
+template < long Value1, long Value2 >
+    struct static_signed_max;
+
+template < unsigned long Value1, unsigned long Value2 >
+    struct static_unsigned_min;
+
+template < unsigned long Value1, unsigned long Value2 >
+    struct static_unsigned_max;
+
+}
+
+ +

Usage

+ +

The four class templates provide the combinations for finding the +minimum or maximum of two signed or unsigned +(long) parameters, Value1 and Value2, +at compile-time. Each template has a single static data member, +value, which is set to the respective minimum or maximum +of the template's parameters.

+ +

Example

+ +
+#include <boost/integer/static_min_max.hpp>
+
+template < unsigned long AddendSize1, unsigned long AddendSize2 >
+class adder
+{
+public:
+    static  unsigned long  const  addend1_size = AddendSize1;
+    static  unsigned long  const  addend2_size = AddendSize2;
+    static  unsigned long  const  sum_size = boost::static_unsigned_max<AddendSize1, AddendSize2>::value + 1;
+
+    typedef int  addend1_type[ addend1_size ];
+    typedef int  addend2_type[ addend2_size ];
+    typedef int  sum_type[ sum_size ];
+
+    void  operator ()( addend1_type const &a1, addend2_type const &a2, sum_type &s ) const;
+};
+
+//...
+
+int main()
+{
+    int const   a1[] = { 0, 4, 3 };  // 340
+    int const   a2[] = { 9, 8 };     //  89
+    int         s[ 4 ];
+    adder<3,2>  obj;
+
+    obj( a1, a2, s );  // 's' should be 429 or { 9, 2, 4, 0 }
+    //...
+}
+
+ +

Demonstration Program

+ +

The program static_min_max_test.cpp is a +simplistic demonstration of various comparisons using the compile-time +extrema class templates.

+ +

Rationale

+ +

Sometimes the minimum or maximum of several values needs to be found +for later compile-time processing, e.g. for a bound for another +class template.

+ +

Credits

+ +

The author of the Boost compile-time extrema class templates is Daryle Walker.

+ +
+ +

Revised October 12, 2001

+ +

© Copyright Daryle Walker 2001. Permission to copy, use, +modify, sell and distribute this document is granted provided this +copyright notice appears in all copies. This document is provided +"as is" without express or implied warranty, and with no claim +as to its suitability for any purpose.

+ + diff --git a/test/integer_mask_test.cpp b/test/integer_mask_test.cpp new file mode 100644 index 0000000..4cf7a4e --- /dev/null +++ b/test/integer_mask_test.cpp @@ -0,0 +1,112 @@ +// boost integer_mask.hpp test program -------------------------------------// + +// (C) Copyright Daryle Walker 2001. Permission to copy, use, modify, sell +// and distribute this software is granted provided this copyright +// notice appears in all copies. This software is provided "as is" without +// express or implied warranty, and with no claim as to its suitability for +// any purpose. + +// See http://www.boost.org for most recent version including documentation. + +// Revision History +// 23 Sep 2001 Initial version (Daryle Walker) + +#define BOOST_INCLUDE_MAIN +#include // for main + +#include // for boost::exit_success +#include // for boost::high_bit_mask_t, etc. + +#include // for std::cout (std::endl indirectly) + + +#define PRIVATE_HIGH_BIT_SLOW_TEST(v) BOOST_TEST( ::boost::high_bit_mask_t< \ + (v) >::high_bit == (1ul << (v)) ); +#define PRIVATE_HIGH_BIT_FAST_TEST(v) BOOST_TEST( ::boost::high_bit_mask_t< \ + (v) >::high_bit_fast == (1ul << (v)) ); +#define PRIVATE_HIGH_BIT_TEST(v) do { PRIVATE_HIGH_BIT_SLOW_TEST(v); \ + PRIVATE_HIGH_BIT_FAST_TEST(v); } while (false) + +#define PRIVATE_LOW_BITS_SLOW_TEST(v) BOOST_TEST( ::boost::low_bits_mask_t< \ + (v) >::sig_bits == ((1ul << (v)) - 1) ); +#define PRIVATE_LOW_BITS_FAST_TEST(v) BOOST_TEST( ::boost::low_bits_mask_t< \ + (v) >::sig_bits_fast == ((1ul << (v)) - 1) ); +#define PRIVATE_LOW_BITS_TEST(v) do { PRIVATE_LOW_BITS_SLOW_TEST(v); \ + PRIVATE_LOW_BITS_FAST_TEST(v); } while (false) + + +int test_main( int, char*[] ) +{ + using std::cout; + using std::endl; + + cout << "Doing high_bit_mask_t tests." << endl; + PRIVATE_HIGH_BIT_TEST( 31 ); + PRIVATE_HIGH_BIT_TEST( 30 ); + PRIVATE_HIGH_BIT_TEST( 29 ); + PRIVATE_HIGH_BIT_TEST( 28 ); + PRIVATE_HIGH_BIT_TEST( 27 ); + PRIVATE_HIGH_BIT_TEST( 26 ); + PRIVATE_HIGH_BIT_TEST( 25 ); + PRIVATE_HIGH_BIT_TEST( 24 ); + PRIVATE_HIGH_BIT_TEST( 23 ); + PRIVATE_HIGH_BIT_TEST( 22 ); + PRIVATE_HIGH_BIT_TEST( 21 ); + PRIVATE_HIGH_BIT_TEST( 20 ); + PRIVATE_HIGH_BIT_TEST( 19 ); + PRIVATE_HIGH_BIT_TEST( 18 ); + PRIVATE_HIGH_BIT_TEST( 17 ); + PRIVATE_HIGH_BIT_TEST( 16 ); + PRIVATE_HIGH_BIT_TEST( 15 ); + PRIVATE_HIGH_BIT_TEST( 14 ); + PRIVATE_HIGH_BIT_TEST( 13 ); + PRIVATE_HIGH_BIT_TEST( 12 ); + PRIVATE_HIGH_BIT_TEST( 11 ); + PRIVATE_HIGH_BIT_TEST( 10 ); + PRIVATE_HIGH_BIT_TEST( 9 ); + PRIVATE_HIGH_BIT_TEST( 8 ); + PRIVATE_HIGH_BIT_TEST( 7 ); + PRIVATE_HIGH_BIT_TEST( 6 ); + PRIVATE_HIGH_BIT_TEST( 5 ); + PRIVATE_HIGH_BIT_TEST( 4 ); + PRIVATE_HIGH_BIT_TEST( 3 ); + PRIVATE_HIGH_BIT_TEST( 2 ); + PRIVATE_HIGH_BIT_TEST( 1 ); + PRIVATE_HIGH_BIT_TEST( 0 ); + + cout << "Doing low_bits_mask_t tests." << endl; + PRIVATE_LOW_BITS_TEST( 32 ); // Undefined behavior? Whoops! + PRIVATE_LOW_BITS_TEST( 31 ); + PRIVATE_LOW_BITS_TEST( 30 ); + PRIVATE_LOW_BITS_TEST( 29 ); + PRIVATE_LOW_BITS_TEST( 28 ); + PRIVATE_LOW_BITS_TEST( 27 ); + PRIVATE_LOW_BITS_TEST( 26 ); + PRIVATE_LOW_BITS_TEST( 25 ); + PRIVATE_LOW_BITS_TEST( 24 ); + PRIVATE_LOW_BITS_TEST( 23 ); + PRIVATE_LOW_BITS_TEST( 22 ); + PRIVATE_LOW_BITS_TEST( 21 ); + PRIVATE_LOW_BITS_TEST( 20 ); + PRIVATE_LOW_BITS_TEST( 19 ); + PRIVATE_LOW_BITS_TEST( 18 ); + PRIVATE_LOW_BITS_TEST( 17 ); + PRIVATE_LOW_BITS_TEST( 16 ); + PRIVATE_LOW_BITS_TEST( 15 ); + PRIVATE_LOW_BITS_TEST( 14 ); + PRIVATE_LOW_BITS_TEST( 13 ); + PRIVATE_LOW_BITS_TEST( 12 ); + PRIVATE_LOW_BITS_TEST( 11 ); + PRIVATE_LOW_BITS_TEST( 10 ); + PRIVATE_LOW_BITS_TEST( 9 ); + PRIVATE_LOW_BITS_TEST( 8 ); + PRIVATE_LOW_BITS_TEST( 7 ); + PRIVATE_LOW_BITS_TEST( 6 ); + PRIVATE_LOW_BITS_TEST( 5 ); + PRIVATE_LOW_BITS_TEST( 4 ); + PRIVATE_LOW_BITS_TEST( 3 ); + PRIVATE_LOW_BITS_TEST( 2 ); + PRIVATE_LOW_BITS_TEST( 1 ); + + return boost::exit_success; +} diff --git a/test/static_log2_test.cpp b/test/static_log2_test.cpp new file mode 100644 index 0000000..abc109b --- /dev/null +++ b/test/static_log2_test.cpp @@ -0,0 +1,151 @@ +// Boost static_log2.hpp test program --------------------------------------// + +// (C) Copyright Daryle Walker 2001. Permission to copy, use, modify, sell +// and distribute this software is granted provided this copyright +// notice appears in all copies. This software is provided "as is" without +// express or implied warranty, and with no claim as to its suitability for +// any purpose. + +// See http://www.boost.org for most recent version including documentation. + +// Revision History +// 01 Oct 2001 Initial version (Daryle Walker) + +#define BOOST_INCLUDE_MAIN +#include // for main + +#include // for boost::exit_success +#include // for boost::static_log2 + +#include // for std::cout (std::endl indirectly) + + +// Macros to compact code +#define PRIVATE_LB_TEST( v, e ) BOOST_TEST( ::boost::static_log2::value == e ) + +#define PRIVATE_PRINT_LB( v ) ::std::cout << "boost::static_log2<" << (v) \ + << "> = " << ::boost::static_log2< (v) >::value << '.' << ::std::endl + +// Control to check for a compile-time error +#ifndef CONTROL_LB_0_TEST +#define PRIVATE_LB_0_TEST +#else +#define PRIVATE_LB_0_TEST PRIVATE_PRINT_LB( 0 ) +#endif + + +// Main testing function +int +test_main +( + int , // "argc" is unused + char * [] // "argv" is unused +) +{ + std::cout << "Doing tests on static_log2." << std::endl; + + PRIVATE_LB_0_TEST; + + PRIVATE_LB_TEST( 1, 0 ); + + PRIVATE_LB_TEST( 2, 1 ); + PRIVATE_LB_TEST( 3, 1 ); + + PRIVATE_LB_TEST( 4, 2 ); + PRIVATE_LB_TEST( 5, 2 ); + PRIVATE_LB_TEST( 6, 2 ); + PRIVATE_LB_TEST( 7, 2 ); + + PRIVATE_LB_TEST( 8, 3 ); + PRIVATE_LB_TEST( 9, 3 ); + PRIVATE_LB_TEST( 10, 3 ); + PRIVATE_LB_TEST( 11, 3 ); + PRIVATE_LB_TEST( 12, 3 ); + PRIVATE_LB_TEST( 13, 3 ); + PRIVATE_LB_TEST( 14, 3 ); + PRIVATE_LB_TEST( 15, 3 ); + + PRIVATE_LB_TEST( 16, 4 ); + PRIVATE_LB_TEST( 17, 4 ); + PRIVATE_LB_TEST( 18, 4 ); + PRIVATE_LB_TEST( 19, 4 ); + PRIVATE_LB_TEST( 20, 4 ); + PRIVATE_LB_TEST( 21, 4 ); + PRIVATE_LB_TEST( 22, 4 ); + PRIVATE_LB_TEST( 23, 4 ); + PRIVATE_LB_TEST( 24, 4 ); + PRIVATE_LB_TEST( 25, 4 ); + PRIVATE_LB_TEST( 26, 4 ); + PRIVATE_LB_TEST( 27, 4 ); + PRIVATE_LB_TEST( 28, 4 ); + PRIVATE_LB_TEST( 29, 4 ); + PRIVATE_LB_TEST( 30, 4 ); + PRIVATE_LB_TEST( 31, 4 ); + + PRIVATE_LB_TEST( 32, 5 ); + PRIVATE_LB_TEST( 33, 5 ); + PRIVATE_LB_TEST( 34, 5 ); + PRIVATE_LB_TEST( 35, 5 ); + PRIVATE_LB_TEST( 36, 5 ); + PRIVATE_LB_TEST( 37, 5 ); + PRIVATE_LB_TEST( 38, 5 ); + PRIVATE_LB_TEST( 39, 5 ); + PRIVATE_LB_TEST( 40, 5 ); + + PRIVATE_LB_TEST( 63, 5 ); + + PRIVATE_LB_TEST( 64, 6 ); + PRIVATE_LB_TEST( 65, 6 ); + + PRIVATE_LB_TEST( 127, 6 ); + + PRIVATE_LB_TEST( 128, 7 ); + PRIVATE_LB_TEST( 129, 7 ); + + PRIVATE_LB_TEST( 255, 7 ); + + PRIVATE_LB_TEST( 256, 8 ); + PRIVATE_LB_TEST( 257, 8 ); + + PRIVATE_LB_TEST( 511, 8 ); + + PRIVATE_LB_TEST( 512, 9 ); + PRIVATE_LB_TEST( 513, 9 ); + + PRIVATE_LB_TEST( 1023, 9 ); + + PRIVATE_LB_TEST( 1024, 10 ); + PRIVATE_LB_TEST( 1025, 10 ); + + PRIVATE_LB_TEST( 2047, 10 ); + + PRIVATE_LB_TEST( 2048, 11 ); + PRIVATE_LB_TEST( 2049, 11 ); + + PRIVATE_LB_TEST( 4095, 11 ); + + PRIVATE_LB_TEST( 4096, 12 ); + PRIVATE_LB_TEST( 4097, 12 ); + + PRIVATE_LB_TEST( 8191, 12 ); + + PRIVATE_LB_TEST( 8192, 13 ); + PRIVATE_LB_TEST( 8193, 13 ); + + PRIVATE_LB_TEST( 16383, 13 ); + + PRIVATE_LB_TEST( 16384, 14 ); + PRIVATE_LB_TEST( 16385, 14 ); + + PRIVATE_LB_TEST( 32767, 14 ); + + PRIVATE_LB_TEST( 32768, 15 ); + PRIVATE_LB_TEST( 32769, 15 ); + + PRIVATE_LB_TEST( 65535, 15 ); + + PRIVATE_LB_TEST( 65536, 16 ); + PRIVATE_LB_TEST( 65537, 16 ); + + return boost::exit_success; +} diff --git a/test/static_min_max_test.cpp b/test/static_min_max_test.cpp new file mode 100644 index 0000000..7da322c --- /dev/null +++ b/test/static_min_max_test.cpp @@ -0,0 +1,94 @@ +// Boost static_min_max.hpp test program -----------------------------------// + +// (C) Copyright Daryle Walker 2001. Permission to copy, use, modify, sell +// and distribute this software is granted provided this copyright +// notice appears in all copies. This software is provided "as is" without +// express or implied warranty, and with no claim as to its suitability for +// any purpose. + +// See http://www.boost.org for most recent version including documentation. + +// Revision History +// 23 Sep 2001 Initial version (Daryle Walker) + +#define BOOST_INCLUDE_MAIN +#include // for main, BOOST_TEST + +#include // for boost::exit_success +#include // for boost::static_signed_min, etc. + +#include // for std::cout (std::endl indirectly) + + +// Main testing function +int +test_main +( + int , // "argc" is unused + char * [] // "argv" is unused +) +{ + using std::cout; + using std::endl; + using boost::static_signed_min; + using boost::static_signed_max; + using boost::static_unsigned_min; + using boost::static_unsigned_max; + + // Two positives + cout << "Doing tests with two positive values." << endl; + + BOOST_TEST( (static_signed_min< 9, 14>::value) == 9 ); + BOOST_TEST( (static_signed_max< 9, 14>::value) == 14 ); + BOOST_TEST( (static_signed_min<14, 9>::value) == 9 ); + BOOST_TEST( (static_signed_max<14, 9>::value) == 14 ); + + BOOST_TEST( (static_unsigned_min< 9, 14>::value) == 9 ); + BOOST_TEST( (static_unsigned_max< 9, 14>::value) == 14 ); + BOOST_TEST( (static_unsigned_min<14, 9>::value) == 9 ); + BOOST_TEST( (static_unsigned_max<14, 9>::value) == 14 ); + + // Two negatives + cout << "Doing tests with two negative values." << endl; + + BOOST_TEST( (static_signed_min< -8, -101>::value) == -101 ); + BOOST_TEST( (static_signed_max< -8, -101>::value) == -8 ); + BOOST_TEST( (static_signed_min<-101, -8>::value) == -101 ); + BOOST_TEST( (static_signed_max<-101, -8>::value) == -8 ); + + // With zero + cout << "Doing tests with zero and a positive or negative value." << endl; + + BOOST_TEST( (static_signed_min< 0, 14>::value) == 0 ); + BOOST_TEST( (static_signed_max< 0, 14>::value) == 14 ); + BOOST_TEST( (static_signed_min<14, 0>::value) == 0 ); + BOOST_TEST( (static_signed_max<14, 0>::value) == 14 ); + + BOOST_TEST( (static_unsigned_min< 0, 14>::value) == 0 ); + BOOST_TEST( (static_unsigned_max< 0, 14>::value) == 14 ); + BOOST_TEST( (static_unsigned_min<14, 0>::value) == 0 ); + BOOST_TEST( (static_unsigned_max<14, 0>::value) == 14 ); + + BOOST_TEST( (static_signed_min< 0, -101>::value) == -101 ); + BOOST_TEST( (static_signed_max< 0, -101>::value) == 0 ); + BOOST_TEST( (static_signed_min<-101, 0>::value) == -101 ); + BOOST_TEST( (static_signed_max<-101, 0>::value) == 0 ); + + // With identical + cout << "Doing tests with two identical values." << endl; + + BOOST_TEST( (static_signed_min<0, 0>::value) == 0 ); + BOOST_TEST( (static_signed_max<0, 0>::value) == 0 ); + BOOST_TEST( (static_unsigned_min<0, 0>::value) == 0 ); + BOOST_TEST( (static_unsigned_max<0, 0>::value) == 0 ); + + BOOST_TEST( (static_signed_min<14, 14>::value) == 14 ); + BOOST_TEST( (static_signed_max<14, 14>::value) == 14 ); + BOOST_TEST( (static_unsigned_min<14, 14>::value) == 14 ); + BOOST_TEST( (static_unsigned_max<14, 14>::value) == 14 ); + + BOOST_TEST( (static_signed_min< -101, -101>::value) == -101 ); + BOOST_TEST( (static_signed_max< -101, -101>::value) == -101 ); + + return boost::exit_success; +}