Header
-boost/cstdint.hpp Header
-boost/cstdint.hpp The header <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 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 in all implementations,
-because long long is not [yet] included in the C++ standard.
See cstdint_test.cpp for a test program.
-The typedef int#_t, with # replaced by the width, designates a
-signed integer type of exactly # bits; int8_t denotes an 8-bit
-signed integer type. Similarly, the typedef uint#_t
-designates and unsigned integer type of exactly # bits.
These types are optional. However, if an implementation provides integer -types with widths of 8, 16, 32, or 64 bits, it shall define the corresponding -typedef names.
-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 a 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.
Required minimum-width integer types:
-int_least8_tint_least16_tint_least32_tuint_least8_tuint_least16_tuint_least32_tAll other minimum-width integer types are optional.
-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.
-Required fastest minimum-width integer types:
-int_fast8_tint_fast16_tint_fast32_tuint_fast8_tuint_fast16_tuint_fast32_tAll other fastest minimum-width integer types are optional.
-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 required.
-Revised 06 Nov 2007 -
-© Copyright Beman Dawes 2000
- -Distributed under the Boost Software License, Version 1.0. See -www.boost.org/LICENSE_1_0.txt
- - - - \ No newline at end of file diff --git a/doc/Jamfile.v2 b/doc/Jamfile.v2 new file mode 100644 index 0000000..18c50ae --- /dev/null +++ b/doc/Jamfile.v2 @@ -0,0 +1,59 @@ + + +# Copyright John Maddock 2005. Use, modification, and distribution are +# subject to 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) + +using quickbook ; + +xml integer : integer.qbk ; +boostbook standalone + : + integer + : + # HTML options first: + # Use graphics not text for navigation: + |
+Home | +Libraries | +People | +FAQ | +More | +
+
+ The header <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 cstdint_test.cpp for + a test program. +
+
+ 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. +
+
+ 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.
+
+ 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.
+
+ 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_tint_least16_tint_least32_tuint_least8_tuint_least16_tuint_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_tuint_least64_t+ All other minimum-width integer types are optional. +
+
+ 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_tint_fast16_tint_fast32_tuint_fast8_tuint_fast16_tuint_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_tuint_fast64_t+ All other fastest minimum-width integer types are optional. +
+
+ 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. +
++ 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); ++
| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+boost::static_log2, boost::static_signed_min,
+ boost::static_signed_max, boost::static_unsigned_minboost::static_unsigned_max,
+ when available.
+ 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).
+ 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).
+ | + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ The <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. +
+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 ++
+ 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. +
+
+ 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 1. Criteria for the Sized Type Class Templates
+|
+ + Class Template + + |
+
+ + Template Parameter Mapping + + |
+
|---|---|
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
|
+
+ |
+
+ + 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. + + |
+
#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; +} ++
+ The program integer_test.cpp + is a simplistic demonstration of the results from instantiating various examples + of the sized type class templates. +
++ The rationale for the design of the templates in this header includes: +
++ If the number of bits required is known beforehand, it may be more appropriate + to use the types supplied in <boost/cstdint.hpp>. +
++ The author of most of the Boost integer type choosing templates is Beman Dawes. He + gives thanks to Valentin Bonnard and Kevlin + Henney for sharing their designs for similar templates. Daryle + Walker designed the value-based sized templates. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ 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. +
+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 ++
+ 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).
+ + The program static_log2_test.cpp + is a simplistic demonstration of the results from instantiating various examples + of the binary logarithm class template. +
++ 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). +
++ The original version of the Boost binary logarithm class template was written + by 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. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ 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. +
+#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 ++
+ 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.
+
Table 2. Members of the `boost::high_bit_mask_t` Class Template
+|
+ + Member + + |
+
+ + Meaning + + |
+
|---|---|
|
+
+ |
+
+ + The smallest, unsigned, built-in type that supports the given bit position. + + |
+
|
+
+ |
+
+
+ The easiest-to-manipulate analog of |
+
|
+
+ |
+
+
+ A |
+
|
+
+ |
+
+
+ A |
+
|
+
+ |
+
+ + The value of the template parameter, in case its needed from a renamed + instantiation of the class template. + + |
+
+ The boost::low_bits_mask_t class template provides constants
+ for bit masks equivalent to the value (2Bits - 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 3. Members of the [^boost::low_bits_mask_t] Class Template
+|
+ + Member + + |
+
+ + Meaning + + |
+
|---|---|
|
+
+ |
+
+ + The smallest, unsigned built-in type that supports the given bit count. + + |
+
|
+
+ |
+
+
+ The easiest-to-manipulate analog of |
+
|
+
+ |
+
+
+ A |
+
|
+
+ |
+
+
+ A |
+
|
+
+ |
+
+ + The value of the template parameter, in case its needed from a renamed + instantiation of the class template. + + |
+
+ 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.
+
#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; + + //... +} ++
+ The program integer_mask_test.cpp + is a simplistic demonstration of the results from instantiating various examples + of the bit mask class templates. +
++ 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 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. +
++ The author of the Boost bit mask class templates is Daryle + Walker. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
++ 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. +
+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; + +} ++
+ 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.
+
#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 } + //... +} ++
+ The program static_min_max_test.cpp + is a simplistic demonstration of various comparisons using the compile-time + extrema class templates. +
++ 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. +
++ The author of the Boost compile-time extrema class templates is Daryle + Walker. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+ 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.
+
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; + }; +} ++
+ 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:
+
|
+ + member + + |
+
+ + type + + |
+
+ + value + + |
+
|---|---|---|
|
+
+ |
+
+ + bool + + |
+
+
+ |
+
|
+
+ |
+
+
+ |
+
+
+ equivalent to |
+
|
+
+ |
+
+
+ |
+
+
+ equivalent to |
+
+ 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.
+
+ The program integer_traits_test.cpp
+ exercises the integer_traits class.
+
+ Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer + traits idea on the boost mailing list in August 1999. +
+| + | + |
+ |
+Home | +Libraries | +People | +FAQ | +More | +
Copyright © 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota, + John Maddock
+ 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) +
+Table of Contents
+ +
+ 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.
+
|
+ + Component + + |
+
+ + Header + + |
+
+ + Purpose + + |
+
|---|---|---|
|
+ + Forward Declarations. + + |
++ + | +
+ + Forward declarations of classes and class templates - for use when + just the name of a class is needed. + + |
+
| + + | ++ + | +
+
+ Provides typedef's based on the 1999 C Standard header |
+
|
+ + Integer Traits. + + |
++ + | +
+
+ Class template |
+
| + + | ++ + | +
+ + 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. + + |
+
|
+ + Integer Masks. + + |
++ + | +
+ + 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. + + |
+
| + + | ++ + | +
+ + 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. + + |
+
| + + | ++ + | +
+ + Templates for finding the extrema of two numbers: Use to find a bound + based on a minimum or maximum value. Useful for generic programming. + + |
+
Last revised: December 11, 2009 at 17:54:58 GMT |
++ |
Integer Bit Mask TemplatesThe 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.
- -
-#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
-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.
| Member | -Meaning | -
|---|---|
least |
- The smallest unsigned built-in type that supports the given - bit position. | -
fast |
- The quick-to-manipulate analog of least. |
-
high_bit |
- A least constant of the desired bit-masking
- value. |
-
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. | -
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.
| Member | -Meaning | -
|---|---|
least |
- The smallest unsigned built-in type that supports the given - bit count. | -
fast |
- The quick-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. | -
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.
-#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;
-
- //...
-}
-The program integer_mask_test.cpp -is a simplistic demonstration of the results from instantiating various -examples of the bit mask class templates.
- -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.
- -The author of the Boost bit mask class templates is Daryle Walker.
- -Revised September 23, 2001
- -© Copyright Daryle Walker 2001. Use, modification, and distribution are -subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
- - diff --git a/doc/static_log2.html b/doc/static_log2.html deleted file mode 100644 index b77874c..0000000 --- a/doc/static_log2.html +++ /dev/null @@ -1,215 +0,0 @@ - - - - - - -Binary Logarithm TemplateThe 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.
- - - -
-
-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
-
-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).
-
-#include "boost/integer/static_log2.hpp"
-
-
-template < boost::static_log2_argument_type 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>();
- //...
-}
-
-The program static_log2_test.cpp -is a simplistic demonstration of the results from instantiating various -examples of the binary logarithm class template.
- - - -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.
- - - -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).
-The original version of the Boost binary logarithm class template was -written by 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. -
- -Revised July 19, 2004
- -© Copyright Daryle Walker 2001.
- © Copyright Gennaro Prota 2004.
Compile-Time Extrema
-TemplatesThe 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.
- -
-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;
-
-}
-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.
-#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 }
- //...
-}
-The program static_min_max_test.cpp is a -simplistic demonstration of various comparisons using the compile-time -extrema class templates.
- -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.
- -The author of the Boost compile-time extrema class templates is Daryle Walker.
- -Revised October 12, 2001
- -© Copyright Daryle Walker 2001. Use, modification, and distribution are -subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
- - diff --git a/include/boost/cstdint.hpp b/include/boost/cstdint.hpp index d55a484..47e6a16 100644 --- a/include/boost/cstdint.hpp +++ b/include/boost/cstdint.hpp @@ -23,10 +23,25 @@ #ifndef BOOST_CSTDINT_HPP #define BOOST_CSTDINT_HPP +// +// Since we always define the INT#_C macros as per C++0x, +// define __STDC_CONSTANT_MACROS so that |
- Home | -Libraries | -People | -FAQ | -More | -
| Header / Docs | -Contents | -Use | -
|---|---|---|
| <boost/integer_fwd.hpp> | -Forward declarations of classes and class templates | -When just the name of a class is needed | -
<boost/cstdint.hpp>- documentation - |
- 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. |
- Supplies typedefs for standard integer types such as int32_t or uint_least16_t.
- Use in preference to <stdint.h>
- for enhanced portability. Furthermore, all names are safely placed in the boost namespace. |
-
<boost/integer_traits.hpp>- - documentation - |
- Template class boost::integer_traits, derived from std::numeric_limits.
- Adds const_min and const_max members. |
- Use to obtain the characteristics of a known integer type. | -
<boost/integer.hpp>documentation |
- Templates for integer type selection based on properties such as - maximum value or number of bits. | -Use to select the type an integer when some property such as maximum value or number of bits is known. - Useful for generic programming. | -
<boost/integer/integer_mask.hpp>documentation |
- 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. | -
<boost/integer/static_log2.hpp>documentation |
- 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. | -
<boost/integer/static_min_max.hpp>documentation |
- Templates for finding the extrema of two numbers. | -Use to find a bound based on a minimum or maximum value. - Useful for generic programming. | -
The organization of boost integer headers and classes is designed to
-take advantage of <stdint.h> types from the 1999 C
-standard without resorting to 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. As always, 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.
- -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.
Revised: 06 Nov 2007 -
- -© Copyright Beman Dawes 2003
- -Distributed under the Boost Software License, Version 1.0. See -www.boost.org/LICENSE_1_0.txt
- + +Automatic redirection failed, please go to +doc/html/index.html. +Copyright Beman Dawes, Daryle Walker, Gennaro Prota and John Maddock 2001-2009
+Distributed under the Boost Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at www.boost.org/LICENSE_1_0.txt).
- \ No newline at end of file + + + + + diff --git a/integer.htm b/integer.htm deleted file mode 100644 index 3d3f9c5..0000000 --- a/integer.htm +++ /dev/null @@ -1,212 +0,0 @@ - - - -Integer Type Selection
-TemplatesThe <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.
- -namespace boost
-{
- // fast integers from least integers
- template< typename LeastInt >
- struct int_fast_t
- {
- typedef implementation_supplied fast;
- };
-
- // signed
- template< int Bits >
- struct int_t
- {
- typedef implementation_supplied least;
- typedef int_fast_t<least>::fast fast;
- };
-
- // unsigned
- template< int Bits >
- struct uint_t
- {
- typedef implementation_supplied least;
- typedef int_fast_t<least>::fast fast;
- };
-
- // signed
- template< long MaxValue >
- struct int_max_value_t
- {
- typedef implementation_supplied least;
- typedef int_fast_t<least>::fast fast;
- };
-
- template< long MinValue >
- struct int_min_value_t
- {
- typedef implementation_supplied least;
- typedef int_fast_t<least>::fast fast;
- };
-
- // unsigned
- template< unsigned long Value >
- struct uint_value_t
- {
- typedef implementation_supplied least;
- typedef int_fast_t<least>::fast fast;
- };
-} // namespace boost
-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, despite the name.
-The output type is given as the class member fast.
Implementation Notes
-By default, the output type is identical to the input type. Eventually,
-this code's implementation should be conditionalized for each platform
-to give accurate mappings between the built-in types and the
-easiest-to-manipulate built-in types. Also, there is no guarantee that
-the output type actually is easier to manipulate than the input
-type.
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 class member least. The easiest-to-manipulate
-version of that type is given by the class member fast.
-The following table describes each template's criteria.
| Class Template | -Template Parameter Mapping | -
|---|---|
boost::int_t |
- 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
- long. |
-
boost::uint_t |
- 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 unsigned
- long. |
-
boost::int_max_value_t |
- The smallest built-in signed integral type that supports the - given value as a maximum. The parameter should be a - positive number. | -
boost::int_min_value_t |
- The smallest built-in signed integral type that supports the - given value as a minimum. The parameter should be a - negative number. | -
boost::uint_value_t |
- The smallest built-in unsigned integral type that supports - the given value as a maximum. The parameter should be a - positive number. | -
#include <boost/integer.hpp>
-
-//...
-
-int main()
-{
- boost::int_t<24>::least my_var;
- //...
-}
-The program integer_test.cpp is a -simplistic demonstration of the results from instantiating various -examples of the sized type class templates.
- -The rationale for the design of the templates in this header includes:
- -If the number of bits required is known beforehand, it may be more -appropriate to use the types supplied in <boost/cstdint.hpp>.
- -The author of most of the Boost integer type choosing templates is Beman Dawes. He gives thanks -to Valentin Bonnard and - Kevlin Henney for sharing -their designs for similar templates. Daryle Walker designed the -value-based sized templates.
- -Revised May 20, 2001
- -© Copyright Beman Dawes 1999. Use, modification, and distribution are -subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
- - diff --git a/integer_traits.html b/integer_traits.html deleted file mode 100644 index 6fc75b8..0000000 --- a/integer_traits.html +++ /dev/null @@ -1,94 +0,0 @@ - - - - - -Compile-Time Integral
-Type Limits-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 integers - static T min() throw(); - static T max() throw(); - static const int digits; // for integers, # value bits - static const int digits10; - static const bool is_signed; - static const bool is_integer; // will be true for integers-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.
-
-
-
integer_traits.hpp Synopsisnamespace boost {
- template<class T>
- class integer_traits : public std::numeric_limits<T>
- {
- static const bool is_integral = false;
- };
-
- // specializations for all integral types
-}
-
-
-integer_traits is derived from
-std::numeric_limits. In general, it 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:
--
| 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: A flag is_integral is provided, because a
-user-defined integer class should specialize
-std::numeric_limits<>::is_integer = true,
-nonetheless compile-time constants const_min and
-const_max cannot be provided for that user-defined class.
-
-
-
-The program integer_traits_test.cpp
-exercises the integer_traits class.
-
-
Revised -06 November 2007
-© Copyright Beman Dawes 2000
- -Distributed under the Boost Software License, Version 1.0. See -www.boost.org/LICENSE_1_0.txt
- diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 1609bf5..690befa 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -4,17 +4,22 @@ import testing ; +project : requirements