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