Squashed 'third_party/boostorg/integer/' content from commit 66dbc2c
Change-Id: I7c6c0492e5492b9349522c6e7be10f459adf4249
git-subtree-dir: third_party/boostorg/integer
git-subtree-split: 66dbc2c70aecc47d5a711b5dac6da6237721a644
diff --git a/doc/Jamfile.v2 b/doc/Jamfile.v2
new file mode 100644
index 0000000..22d3eca
--- /dev/null
+++ b/doc/Jamfile.v2
@@ -0,0 +1,60 @@
+
+
+# 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:
+ <xsl:param>navig.graphics=1
+ # How far down we chunk nested sections, basically all of them:
+ <xsl:param>chunk.section.depth=1
+ # Don't put the first section on the same page as the TOC:
+ <xsl:param>chunk.first.sections=0
+ # How far down sections get TOC's
+ <xsl:param>toc.section.depth=1
+ # Max depth in each TOC:
+ <xsl:param>toc.max.depth=1
+ # How far down we go with TOC's
+ <xsl:param>generate.section.toc.level=4
+ # Path for links to Boost:
+ <xsl:param>boost.root=../../../..
+
+ # PDF Options:
+ # TOC Generation: this is needed for FOP-0.9 and later:
+ <xsl:param>fop1.extensions=0
+ # Or enable this if you're using XEP:
+ <xsl:param>xep.extensions=1
+ # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+ <xsl:param>fop.extensions=0
+ # No indent on body text:
+ <xsl:param>body.start.indent=0pt
+ # Margin size:
+ <xsl:param>page.margin.inner=0.5in
+ # Margin size:
+ <xsl:param>page.margin.outer=0.5in
+ # Yes, we want graphics for admonishments:
+ <xsl:param>admon.graphics=1
+ # Set this one for PDF generation *only*:
+ # default pnd graphics are awful in PDF form,
+ # better use SVG's instead:
+ <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+ <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
+ <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/regex/doc/html
+ ;
+
+install pdfinstall : standalone/<format>pdf : <location>. <install-type>PDF ;
+explicit pdfinstall ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone ;
+explicit boostrelease ;
diff --git a/doc/gcd/math-gcd.qbk b/doc/gcd/math-gcd.qbk
new file mode 100644
index 0000000..23472de
--- /dev/null
+++ b/doc/gcd/math-gcd.qbk
@@ -0,0 +1,292 @@
+
+[section:gcd_lcm Greatest Common Divisor and Least Common Multiple]
+
+[section Introduction]
+
+The class and function templates in <boost/math/common_factor.hpp>
+provide run-time and compile-time evaluation of the greatest common divisor
+(GCD) or least common multiple (LCM) of two integers.
+These facilities are useful for many numeric-oriented generic
+programming problems.
+
+[endsect]
+
+[section Synopsis]
+
+ namespace boost
+ {
+ namespace math
+ {
+
+ template < typename IntegerType >
+ class gcd_evaluator;
+ template < typename IntegerType >
+ class lcm_evaluator;
+
+ template < typename IntegerType >
+ constexpr IntegerType gcd( IntegerType const &a, IntegerType const &b );
+ template < typename IntegerType >
+ constexpr IntegerType lcm( IntegerType const &a, IntegerType const &b );
+ template < typename IntegerType, typename... Args >
+ constexpr IntegerType gcd( IntegerType const &a, IntegerType const &b, Args const&... );
+ template < typename IntegerType, typename... Args >
+ constexpr IntegerType lcm( IntegerType const &a, IntegerType const &b, Args const&... );
+
+ template <typename I>
+ std::pair<typename std::iterator_traits<I>::value_type, I>
+ gcd_range(I first, I last);
+ template <typename I>
+ std::pair<typename std::iterator_traits<I>::value_type, I>
+ lcm_range(I first, I last);
+
+ typedef ``['see-below]`` static_gcd_type;
+
+ template < static_gcd_type Value1, static_gcd_type Value2 >
+ struct static_gcd;
+ template < static_gcd_type Value1, static_gcd_type Value2 >
+ struct static_lcm;
+
+ }
+ }
+
+[endsect]
+
+[section GCD Function Object]
+
+[*Header: ] [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
+
+ template < typename IntegerType >
+ class boost::math::gcd_evaluator
+ {
+ public:
+ // Types
+ typedef IntegerType result_type;
+ typedef IntegerType first_argument_type;
+ typedef IntegerType second_argument_type;
+
+ // Function object interface
+ constexpr result_type operator ()(
+ first_argument_type const &a,
+ second_argument_type const &b ) const;
+ };
+
+The boost::math::gcd_evaluator class template defines a function object
+class to return the greatest common divisor of two integers.
+The template is parameterized by a single type, called IntegerType here.
+This type should be a numeric type that represents integers.
+The result of the function object is always nonnegative, even if either of
+the operator arguments is negative.
+
+This function object class template is used in the corresponding version of
+the GCD function template. If a numeric type wants to customize evaluations
+of its greatest common divisors, then the type should specialize on the
+gcd_evaluator class template.
+
+Note that these function objects are `constexpr` in C++14 and later only.
+They are also declared `noexcept` when appropriate.
+
+[endsect]
+
+[section LCM Function Object]
+
+[*Header: ] [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
+
+ template < typename IntegerType >
+ class boost::math::lcm_evaluator
+ {
+ public:
+ // Types
+ typedef IntegerType result_type;
+ typedef IntegerType first_argument_type;
+ typedef IntegerType second_argument_type;
+
+ // Function object interface
+ constexpr result_type operator ()(
+ first_argument_type const &a,
+ second_argument_type const &b ) const;
+ };
+
+The boost::math::lcm_evaluator class template defines a function object
+class to return the least common multiple of two integers. The template
+is parameterized by a single type, called IntegerType here. This type
+should be a numeric type that represents integers. The result of the
+function object is always nonnegative, even if either of the operator
+arguments is negative. If the least common multiple is beyond the range
+of the integer type, the results are undefined.
+
+This function object class template is used in the corresponding version
+of the LCM function template. If a numeric type wants to customize
+evaluations of its least common multiples, then the type should
+specialize on the lcm_evaluator class template.
+
+Note that these function objects are constexpr in C++14 and later only.
+They are also declared `noexcept` when appropriate.
+
+[endsect]
+
+[section:run_time Run-time GCD & LCM Determination]
+
+[*Header: ] [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
+
+ template < typename IntegerType >
+ constexpr IntegerType boost::math::gcd( IntegerType const &a, IntegerType const &b );
+
+ template < typename IntegerType >
+ constexpr IntegerType boost::math::lcm( IntegerType const &a, IntegerType const &b );
+
+ template < typename IntegerType, typename... Args >
+ constexpr IntegerType gcd( IntegerType const &a, IntegerType const &b, Args const&... );
+
+ template < typename IntegerType, typename... Args >
+ constexpr IntegerType lcm( IntegerType const &a, IntegerType const &b, Args const&... );
+
+ template <typename I>
+ std::pair<typename std::iterator_traits<I>::value_type, I>
+ gcd_range(I first, I last);
+
+ template <typename I>
+ std::pair<typename std::iterator_traits<I>::value_type, I>
+ lcm_range(I first, I last);
+
+The boost::math::gcd function template returns the greatest common
+(nonnegative) divisor of the two integers passed to it.
+`boost::math::gcd_range` is the iteration of the above gcd algorithm over a
+range, returning the greatest common divisor of all the elements. The algorithm
+terminates when the gcd reaches unity or the end of the range. Thus it also
+returns the iterator after the last element inspected because this may not be
+equal to the end of the range. The variadic version of `gcd` behaves similarly
+but does not indicate which input value caused the gcd to reach unity.
+
+The boost::math::lcm function template returns the least common
+(nonnegative) multiple of the two integers passed to it.
+As with gcd, there are range and variadic versions of the function for
+more than 2 arguments.
+
+Note that these functions are constexpr in C++14 and later only.
+They are also declared `noexcept` when appropriate.
+
+[endsect]
+
+[section:compile_time Compile time GCD and LCM determination]
+
+[note These functions are deprecated in favor of constexpr `gcd` and `lcm` on C++14 capable compilers.]
+
+[*Header: ] [@../../../../boost/math/common_factor_ct.hpp <boost/math/common_factor_ct.hpp>]
+
+ typedef ``['unspecified]`` static_gcd_type;
+
+ template < static_gcd_type Value1, static_gcd_type Value2 >
+ struct boost::math::static_gcd : public mpl::integral_c<static_gcd_type, implementation_defined>
+ {
+ };
+
+ template < static_gcd_type Value1, static_gcd_type Value2 >
+ struct boost::math::static_lcm : public mpl::integral_c<static_gcd_type, implementation_defined>
+ {
+ };
+
+The type `static_gcd_type` is the widest unsigned-integer-type that is supported
+for use in integral-constant-expressions by the compiler. Usually this
+the same type as `boost::uintmax_t`, but may fall back to being `unsigned long`
+for some older compilers.
+
+The boost::math::static_gcd and boost::math::static_lcm class templates
+take two value-based template parameters of the ['static_gcd_type] type
+and inherit from the type `boost::mpl::integral_c`.
+Inherited from the base class, they have a member /value/
+that is the greatest common factor or least
+common multiple, respectively, of the template arguments.
+A compile-time error will occur if the least common multiple
+is beyond the range of `static_gcd_type`.
+
+[h3 Example]
+
+ #include <boost/math/common_factor.hpp>
+ #include <algorithm>
+ #include <iterator>
+ #include <iostream>
+
+ int main()
+ {
+ using std::cout;
+ using std::endl;
+
+ cout << "The GCD and LCM of 6 and 15 are "
+ << boost::math::gcd(6, 15) << " and "
+ << boost::math::lcm(6, 15) << ", respectively."
+ << endl;
+
+ cout << "The GCD and LCM of 8 and 9 are "
+ << boost::math::static_gcd<8, 9>::value
+ << " and "
+ << boost::math::static_lcm<8, 9>::value
+ << ", respectively." << endl;
+
+ int a[] = { 4, 5, 6 }, b[] = { 7, 8, 9 }, c[3];
+ std::transform( a, a + 3, b, c, boost::math::gcd_evaluator<int>() );
+ std::copy( c, c + 3, std::ostream_iterator<int>(cout, " ") );
+ }
+
+[endsect]
+
+[section:gcd_header Header <boost/math/common_factor.hpp>]
+
+This header simply includes the headers
+[@../../../../boost/math/common_factor_ct.hpp <boost/math/common_factor_ct.hpp>]
+and [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>].
+
+Note this is a legacy header: it used to contain the actual implementation,
+but the compile-time and run-time facilities
+were moved to separate headers (since they were independent of each other).
+
+[endsect]
+
+[section:demo Demonstration Program]
+
+The program [@../../../../libs/math/test/common_factor_test.cpp common_factor_test.cpp] is a demonstration of the results from
+instantiating various examples of the run-time GCD and LCM function
+templates and the compile-time GCD and LCM class templates.
+(The run-time GCD and LCM class templates are tested indirectly through
+the run-time function templates.)
+
+[endsect]
+
+[section Rationale]
+
+The greatest common divisor and least common multiple functions are
+greatly used in some numeric contexts, including some of the other
+Boost libraries. Centralizing these functions to one header improves
+code factoring and eases maintainence.
+
+[endsect]
+
+[section:gcd_history History]
+
+* 24th April 2017 Moved to Jeremy Murphy's improved algorithms, added constexpr and noexcept support,
+added compiler intrinsic support, added variadic and range based versions of the algorithms.
+* 13 May 2013 Moved into main Boost.Math Quickbook documentation.
+* 17 Dec 2005: Converted documentation to Quickbook Format.
+* 2 Jul 2002: Compile-time and run-time items separated to new headers.
+* 7 Nov 2001: Initial version
+
+[endsect]
+
+[section:gcd_credits Credits]
+
+The author of the Boost compilation of GCD and LCM computations is
+Daryle Walker. The code was prompted by existing code hiding in the
+implementations of Paul Moore's rational library and Steve Cleary's
+pool library. The code had updates by Helmut Zeisel.
+
+[endsect]
+
+[endsect]
+
+[/
+Copyright 2005, 2013 Daryle Walker.
+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).
+]
+
+
diff --git a/doc/html/boost_integer/cstdint.html b/doc/html/boost_integer/cstdint.html
new file mode 100644
index 0000000..cb0223f
--- /dev/null
+++ b/doc/html/boost_integer/cstdint.html
@@ -0,0 +1,49 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Removed from library: Standard Integer Types</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="history.html" title="History">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="history.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.cstdint"></a><a class="link" href="cstdint.html" title="Removed from library: Standard Integer Types">Removed from library: Standard Integer
+ Types</a>
+</h2></div></div></div>
+<p>
+ The <a href="../../../../../libs/config/doc/html/boost_config/cstdint.html" target="_top">Boost.Config</a>
+ module provides the typedefs useful for writing portable code that requires
+ certain integer widths.
+ </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2001-2009 Beman
+ Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="history.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
+</div>
+</body>
+</html>
diff --git a/doc/html/boost_integer/gcd_lcm.html b/doc/html/boost_integer/gcd_lcm.html
new file mode 100644
index 0000000..097afc0
--- /dev/null
+++ b/doc/html/boost_integer/gcd_lcm.html
@@ -0,0 +1,400 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Greatest Common Divisor and Least Common Multiple</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="integer.html" title="Integer Type Selection">
+<link rel="next" href="mask.html" title="Integer Masks">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="integer.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mask.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.gcd_lcm"></a><a class="link" href="gcd_lcm.html" title="Greatest Common Divisor and Least Common Multiple">Greatest Common Divisor and Least
+ Common Multiple</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.introduction">Introduction</a></span></dt>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.gcd_function_object">GCD Function
+ Object</a></span></dt>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.lcm_function_object">LCM Function
+ Object</a></span></dt>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.run_time">Run-time GCD & LCM
+ Determination</a></span></dt>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.compile_time">Compile time GCD
+ and LCM determination</a></span></dt>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.gcd_header">Header <boost/math/common_factor.hpp></a></span></dt>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.demo">Demonstration Program</a></span></dt>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.rationale">Rationale</a></span></dt>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.gcd_history">History</a></span></dt>
+<dt><span class="section"><a href="gcd_lcm.html#boost_integer.gcd_lcm.gcd_credits">Credits</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.introduction"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.introduction" title="Introduction">Introduction</a>
+</h3></div></div></div>
+<p>
+ The class and function templates in <boost/math/common_factor.hpp>
+ provide run-time and compile-time evaluation of the greatest common divisor
+ (GCD) or least common multiple (LCM) of two integers. These facilities are
+ useful for many numeric-oriented generic programming problems.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.synopsis"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
+<span class="special">{</span>
+<span class="keyword">namespace</span> <span class="identifier">math</span>
+<span class="special">{</span>
+
+<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">></span>
+ <span class="keyword">class</span> <span class="identifier">gcd_evaluator</span><span class="special">;</span>
+<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">></span>
+ <span class="keyword">class</span> <span class="identifier">lcm_evaluator</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">></span>
+ <span class="keyword">constexpr</span> <span class="identifier">IntegerType</span> <span class="identifier">gcd</span><span class="special">(</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">b</span> <span class="special">);</span>
+<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">></span>
+ <span class="keyword">constexpr</span> <span class="identifier">IntegerType</span> <span class="identifier">lcm</span><span class="special">(</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">b</span> <span class="special">);</span>
+<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span><span class="special">,</span> <span class="keyword">typename</span><span class="special">...</span> <span class="identifier">Args</span> <span class="special">></span>
+ <span class="keyword">constexpr</span> <span class="identifier">IntegerType</span> <span class="identifier">gcd</span><span class="special">(</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">Args</span> <span class="keyword">const</span><span class="special">&...</span> <span class="special">);</span>
+<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span><span class="special">,</span> <span class="keyword">typename</span><span class="special">...</span> <span class="identifier">Args</span> <span class="special">></span>
+ <span class="keyword">constexpr</span> <span class="identifier">IntegerType</span> <span class="identifier">lcm</span><span class="special">(</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">Args</span> <span class="keyword">const</span><span class="special">&...</span> <span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">></span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special"><</span><span class="identifier">I</span><span class="special">>::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">I</span><span class="special">></span>
+ <span class="identifier">gcd_range</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">last</span><span class="special">);</span>
+<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">></span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special"><</span><span class="identifier">I</span><span class="special">>::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">I</span><span class="special">></span>
+ <span class="identifier">lcm_range</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">last</span><span class="special">);</span>
+
+<span class="keyword">typedef</span> <span class="emphasis"><em>see-below</em></span> <span class="identifier">static_gcd_type</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special"><</span> <span class="identifier">static_gcd_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_gcd_type</span> <span class="identifier">Value2</span> <span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">static_gcd</span><span class="special">;</span>
+<span class="keyword">template</span> <span class="special"><</span> <span class="identifier">static_gcd_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_gcd_type</span> <span class="identifier">Value2</span> <span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">static_lcm</span><span class="special">;</span>
+
+<span class="special">}</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.gcd_function_object"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.gcd_function_object" title="GCD Function Object">GCD Function
+ Object</a>
+</h3></div></div></div>
+<p>
+ <span class="bold"><strong>Header: </strong></span> <a href="../../../../../boost/math/common_factor_rt.hpp" target="_top"><boost/math/common_factor_rt.hpp></a>
+ </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">></span>
+<span class="keyword">class</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">gcd_evaluator</span>
+<span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+ <span class="comment">// Types</span>
+ <span class="keyword">typedef</span> <span class="identifier">IntegerType</span> <span class="identifier">result_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">IntegerType</span> <span class="identifier">first_argument_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">IntegerType</span> <span class="identifier">second_argument_type</span><span class="special">;</span>
+
+ <span class="comment">// Function object interface</span>
+ <span class="keyword">constexpr</span> <span class="identifier">result_type</span> <span class="keyword">operator</span> <span class="special">()(</span>
+ <span class="identifier">first_argument_type</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a</span><span class="special">,</span>
+ <span class="identifier">second_argument_type</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">b</span> <span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<p>
+ The boost::math::gcd_evaluator class template defines a function object class
+ to return the greatest common divisor of two integers. The template is parameterized
+ by a single type, called IntegerType here. This type should be a numeric
+ type that represents integers. The result of the function object is always
+ nonnegative, even if either of the operator arguments is negative.
+ </p>
+<p>
+ This function object class template is used in the corresponding version
+ of the GCD function template. If a numeric type wants to customize evaluations
+ of its greatest common divisors, then the type should specialize on the gcd_evaluator
+ class template.
+ </p>
+<p>
+ Note that these function objects are <code class="computeroutput"><span class="keyword">constexpr</span></code>
+ in C++14 and later only. They are also declared <code class="computeroutput"><span class="keyword">noexcept</span></code>
+ when appropriate.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.lcm_function_object"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.lcm_function_object" title="LCM Function Object">LCM Function
+ Object</a>
+</h3></div></div></div>
+<p>
+ <span class="bold"><strong>Header: </strong></span> <a href="../../../../../boost/math/common_factor_rt.hpp" target="_top"><boost/math/common_factor_rt.hpp></a>
+ </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">></span>
+<span class="keyword">class</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">lcm_evaluator</span>
+<span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+ <span class="comment">// Types</span>
+ <span class="keyword">typedef</span> <span class="identifier">IntegerType</span> <span class="identifier">result_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">IntegerType</span> <span class="identifier">first_argument_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">IntegerType</span> <span class="identifier">second_argument_type</span><span class="special">;</span>
+
+ <span class="comment">// Function object interface</span>
+ <span class="keyword">constexpr</span> <span class="identifier">result_type</span> <span class="keyword">operator</span> <span class="special">()(</span>
+ <span class="identifier">first_argument_type</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a</span><span class="special">,</span>
+ <span class="identifier">second_argument_type</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">b</span> <span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<p>
+ The boost::math::lcm_evaluator class template defines a function object class
+ to return the least common multiple of two integers. The template is parameterized
+ by a single type, called IntegerType here. This type should be a numeric
+ type that represents integers. The result of the function object is always
+ nonnegative, even if either of the operator arguments is negative. If the
+ least common multiple is beyond the range of the integer type, the results
+ are undefined.
+ </p>
+<p>
+ This function object class template is used in the corresponding version
+ of the LCM function template. If a numeric type wants to customize evaluations
+ of its least common multiples, then the type should specialize on the lcm_evaluator
+ class template.
+ </p>
+<p>
+ Note that these function objects are constexpr in C++14 and later only. They
+ are also declared <code class="computeroutput"><span class="keyword">noexcept</span></code> when
+ appropriate.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.run_time"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.run_time" title="Run-time GCD & LCM Determination">Run-time GCD & LCM
+ Determination</a>
+</h3></div></div></div>
+<p>
+ <span class="bold"><strong>Header: </strong></span> <a href="../../../../../boost/math/common_factor_rt.hpp" target="_top"><boost/math/common_factor_rt.hpp></a>
+ </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">></span>
+<span class="keyword">constexpr</span> <span class="identifier">IntegerType</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">gcd</span><span class="special">(</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">b</span> <span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">></span>
+<span class="keyword">constexpr</span> <span class="identifier">IntegerType</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">lcm</span><span class="special">(</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">b</span> <span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span><span class="special">,</span> <span class="keyword">typename</span><span class="special">...</span> <span class="identifier">Args</span> <span class="special">></span>
+ <span class="keyword">constexpr</span> <span class="identifier">IntegerType</span> <span class="identifier">gcd</span><span class="special">(</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">Args</span> <span class="keyword">const</span><span class="special">&...</span> <span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span><span class="special">,</span> <span class="keyword">typename</span><span class="special">...</span> <span class="identifier">Args</span> <span class="special">></span>
+ <span class="keyword">constexpr</span> <span class="identifier">IntegerType</span> <span class="identifier">lcm</span><span class="special">(</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">Args</span> <span class="keyword">const</span><span class="special">&...</span> <span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">></span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special"><</span><span class="identifier">I</span><span class="special">>::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">I</span><span class="special">></span>
+ <span class="identifier">gcd_range</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">last</span><span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">></span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special"><</span><span class="identifier">I</span><span class="special">>::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">I</span><span class="special">></span>
+ <span class="identifier">lcm_range</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">last</span><span class="special">);</span>
+</pre>
+<p>
+ The boost::math::gcd function template returns the greatest common (nonnegative)
+ divisor of the two integers passed to it. <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">gcd_range</span></code>
+ is the iteration of the above gcd algorithm over a range, returning the greatest
+ common divisor of all the elements. The algorithm terminates when the gcd
+ reaches unity or the end of the range. Thus it also returns the iterator
+ after the last element inspected because this may not be equal to the end
+ of the range. The variadic version of <code class="computeroutput"><span class="identifier">gcd</span></code>
+ behaves similarly but does not indicate which input value caused the gcd
+ to reach unity.
+ </p>
+<p>
+ The boost::math::lcm function template returns the least common (nonnegative)
+ multiple of the two integers passed to it. As with gcd, there are range and
+ variadic versions of the function for more than 2 arguments.
+ </p>
+<p>
+ Note that these functions are constexpr in C++14 and later only. They are
+ also declared <code class="computeroutput"><span class="keyword">noexcept</span></code> when
+ appropriate.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.compile_time"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.compile_time" title="Compile time GCD and LCM determination">Compile time GCD
+ and LCM determination</a>
+</h3></div></div></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ These functions are deprecated in favor of constexpr <code class="computeroutput"><span class="identifier">gcd</span></code>
+ and <code class="computeroutput"><span class="identifier">lcm</span></code> on C++14 capable
+ compilers.
+ </p></td></tr>
+</table></div>
+<p>
+ <span class="bold"><strong>Header: </strong></span> <a href="../../../../../boost/math/common_factor_ct.hpp" target="_top"><boost/math/common_factor_ct.hpp></a>
+ </p>
+<pre class="programlisting"><span class="keyword">typedef</span> <span class="emphasis"><em>unspecified</em></span> <span class="identifier">static_gcd_type</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special"><</span> <span class="identifier">static_gcd_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_gcd_type</span> <span class="identifier">Value2</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">static_gcd</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">integral_c</span><span class="special"><</span><span class="identifier">static_gcd_type</span><span class="special">,</span> <span class="identifier">implementation_defined</span><span class="special">></span>
+<span class="special">{</span>
+<span class="special">};</span>
+
+<span class="keyword">template</span> <span class="special"><</span> <span class="identifier">static_gcd_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_gcd_type</span> <span class="identifier">Value2</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">static_lcm</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">integral_c</span><span class="special"><</span><span class="identifier">static_gcd_type</span><span class="special">,</span> <span class="identifier">implementation_defined</span><span class="special">></span>
+<span class="special">{</span>
+<span class="special">};</span>
+</pre>
+<p>
+ The type <code class="computeroutput"><span class="identifier">static_gcd_type</span></code>
+ is the widest unsigned-integer-type that is supported for use in integral-constant-expressions
+ by the compiler. Usually this the same type as <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">uintmax_t</span></code>,
+ but may fall back to being <code class="computeroutput"><span class="keyword">unsigned</span>
+ <span class="keyword">long</span></code> for some older compilers.
+ </p>
+<p>
+ The boost::math::static_gcd and boost::math::static_lcm class templates take
+ two value-based template parameters of the <span class="emphasis"><em>static_gcd_type</em></span>
+ type and inherit from the type <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">integral_c</span></code>. Inherited from the base class,
+ they have a member <span class="emphasis"><em>value</em></span> that is the greatest common
+ factor or least common multiple, respectively, of the template arguments.
+ A compile-time error will occur if the least common multiple is beyond the
+ range of <code class="computeroutput"><span class="identifier">static_gcd_type</span></code>.
+ </p>
+<h4>
+<a name="boost_integer.gcd_lcm.compile_time.h0"></a>
+ <span class="phrase"><a name="boost_integer.gcd_lcm.compile_time.example"></a></span><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.compile_time.example">Example</a>
+ </h4>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">common_factor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
+<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">algorithm</span><span class="special">></span>
+<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iterator</span><span class="special">></span>
+<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+ <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">;</span>
+ <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+ <span class="identifier">cout</span> <span class="special"><<</span> <span class="string">"The GCD and LCM of 6 and 15 are "</span>
+ <span class="special"><<</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">gcd</span><span class="special">(</span><span class="number">6</span><span class="special">,</span> <span class="number">15</span><span class="special">)</span> <span class="special"><<</span> <span class="string">" and "</span>
+ <span class="special"><<</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">lcm</span><span class="special">(</span><span class="number">6</span><span class="special">,</span> <span class="number">15</span><span class="special">)</span> <span class="special"><<</span> <span class="string">", respectively."</span>
+ <span class="special"><<</span> <span class="identifier">endl</span><span class="special">;</span>
+
+ <span class="identifier">cout</span> <span class="special"><<</span> <span class="string">"The GCD and LCM of 8 and 9 are "</span>
+ <span class="special"><<</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">static_gcd</span><span class="special"><</span><span class="number">8</span><span class="special">,</span> <span class="number">9</span><span class="special">>::</span><span class="identifier">value</span>
+ <span class="special"><<</span> <span class="string">" and "</span>
+ <span class="special"><<</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">static_lcm</span><span class="special"><</span><span class="number">8</span><span class="special">,</span> <span class="number">9</span><span class="special">>::</span><span class="identifier">value</span>
+ <span class="special"><<</span> <span class="string">", respectively."</span> <span class="special"><<</span> <span class="identifier">endl</span><span class="special">;</span>
+
+ <span class="keyword">int</span> <span class="identifier">a</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="number">4</span><span class="special">,</span> <span class="number">5</span><span class="special">,</span> <span class="number">6</span> <span class="special">},</span> <span class="identifier">b</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="number">7</span><span class="special">,</span> <span class="number">8</span><span class="special">,</span> <span class="number">9</span> <span class="special">},</span> <span class="identifier">c</span><span class="special">[</span><span class="number">3</span><span class="special">];</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">transform</span><span class="special">(</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">a</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">gcd_evaluator</span><span class="special"><</span><span class="keyword">int</span><span class="special">>()</span> <span class="special">);</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">c</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special"><</span><span class="keyword">int</span><span class="special">>(</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">" "</span><span class="special">)</span> <span class="special">);</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.gcd_header"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.gcd_header" title="Header <boost/math/common_factor.hpp>">Header <boost/math/common_factor.hpp></a>
+</h3></div></div></div>
+<p>
+ This header simply includes the headers <a href="../../../../../boost/math/common_factor_ct.hpp" target="_top"><boost/math/common_factor_ct.hpp></a>
+ and <a href="../../../../../boost/math/common_factor_rt.hpp" target="_top"><boost/math/common_factor_rt.hpp></a>.
+ </p>
+<p>
+ Note this is a legacy header: it used to contain the actual implementation,
+ but the compile-time and run-time facilities were moved to separate headers
+ (since they were independent of each other).
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.demo"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.demo" title="Demonstration Program">Demonstration Program</a>
+</h3></div></div></div>
+<p>
+ The program <a href="../../../../../libs/math/test/common_factor_test.cpp" target="_top">common_factor_test.cpp</a>
+ is a demonstration of the results from instantiating various examples of
+ the run-time GCD and LCM function templates and the compile-time GCD and
+ LCM class templates. (The run-time GCD and LCM class templates are tested
+ indirectly through the run-time function templates.)
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.rationale"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.rationale" title="Rationale">Rationale</a>
+</h3></div></div></div>
+<p>
+ The greatest common divisor and least common multiple functions are greatly
+ used in some numeric contexts, including some of the other Boost libraries.
+ Centralizing these functions to one header improves code factoring and eases
+ maintainence.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.gcd_history"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.gcd_history" title="History">History</a>
+</h3></div></div></div>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ 24th April 2017 Moved to Jeremy Murphy's improved algorithms, added constexpr
+ and noexcept support, added compiler intrinsic support, added variadic
+ and range based versions of the algorithms.
+ </li>
+<li class="listitem">
+ 13 May 2013 Moved into main Boost.Math Quickbook documentation.
+ </li>
+<li class="listitem">
+ 17 Dec 2005: Converted documentation to Quickbook Format.
+ </li>
+<li class="listitem">
+ 2 Jul 2002: Compile-time and run-time items separated to new headers.
+ </li>
+<li class="listitem">
+ 7 Nov 2001: Initial version
+ </li>
+</ul></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.gcd_lcm.gcd_credits"></a><a class="link" href="gcd_lcm.html#boost_integer.gcd_lcm.gcd_credits" title="Credits">Credits</a>
+</h3></div></div></div>
+<p>
+ The author of the Boost compilation of GCD and LCM computations is Daryle
+ Walker. The code was prompted by existing code hiding in the implementations
+ of Paul Moore's rational library and Steve Cleary's pool library. The code
+ had updates by Helmut Zeisel.
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2001-2009 Beman
+ Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="integer.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mask.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/doc/html/boost_integer/history.html b/doc/html/boost_integer/history.html
new file mode 100644
index 0000000..77257ba
--- /dev/null
+++ b/doc/html/boost_integer/history.html
@@ -0,0 +1,90 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>History</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="minmax.html" title="Compile time min/max calculation">
+<link rel="next" href="cstdint.html" title="Removed from library: Standard Integer Types">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="minmax.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cstdint.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.history"></a><a class="link" href="history.html" title="History">History</a>
+</h2></div></div></div>
+<h5>
+<a name="boost_integer.history.h0"></a>
+ <span class="phrase"><a name="boost_integer.history.1_56_0"></a></span><a class="link" href="history.html#boost_integer.history.1_56_0">1.56.0</a>
+ </h5>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ Moved <code class="computeroutput"><span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cstdint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code> into <a href="../../../../../libs/config/index.html" target="_top">Boost.Config</a>.
+ </li></ul></div>
+<h5>
+<a name="boost_integer.history.h1"></a>
+ <span class="phrase"><a name="boost_integer.history.1_42_0"></a></span><a class="link" href="history.html#boost_integer.history.1_42_0">1.42.0</a>
+ </h5>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ Reverted Trunk to release branch state (i.e. a "known good state").
+ </li>
+<li class="listitem">
+ Fixed issues: <a href="https://svn.boost.org/trac/boost/ticket/653" target="_top">653</a>,
+ <a href="https://svn.boost.org/trac/boost/ticket/3084" target="_top">3084</a>,
+ <a href="https://svn.boost.org/trac/boost/ticket/3177" target="_top">3177</a>,
+ <a href="https://svn.boost.org/trac/boost/ticket/3180" target="_top">3180</a>,
+ <a href="https://svn.boost.org/trac/boost/ticket/3548" target="_top">3568</a>,
+ <a href="https://svn.boost.org/trac/boost/ticket/3657" target="_top">3657</a>,
+ <a href="https://svn.boost.org/trac/boost/ticket/2134" target="_top">2134</a>.
+ </li>
+<li class="listitem">
+ Added long long support to <code class="literal">boost::static_log2</code>, <code class="literal">boost::static_signed_min</code>,
+ <code class="literal">boost::static_signed_max</code>, <code class="literal">boost::static_unsigned_min</code><code class="literal">boost::static_unsigned_max</code>,
+ when available.
+ </li>
+<li class="listitem">
+ The argument type and the result type of <code class="literal">boost::static_signed_min</code>
+ etc are now typedef'd. Formerly, they were hardcoded as <code class="literal">unsigned
+ long</code> and <code class="literal">int</code> respectively. Please, use the
+ provided typedefs in new code (and update old code as soon as possible).
+ </li>
+</ul></div>
+<h5>
+<a name="boost_integer.history.h2"></a>
+ <span class="phrase"><a name="boost_integer.history.1_32_0"></a></span><a class="link" href="history.html#boost_integer.history.1_32_0">1.32.0</a>
+ </h5>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+ The argument type and the result type of <code class="literal">boost::static_log2</code>
+ are now typedef'd. Formerly, they were hardcoded as <code class="literal">unsigned long</code>
+ and <code class="literal">int</code> respectively. Please, use the provided typedefs
+ in new code (and update old code as soon as possible).
+ </li></ul></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2001-2009 Beman
+ Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="minmax.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cstdint.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/doc/html/boost_integer/integer.html b/doc/html/boost_integer/integer.html
new file mode 100644
index 0000000..6dc60ef
--- /dev/null
+++ b/doc/html/boost_integer/integer.html
@@ -0,0 +1,432 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Integer Type Selection</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="traits.html" title="Integer Traits">
+<link rel="next" href="gcd_lcm.html" title="Greatest Common Divisor and Least Common Multiple">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="traits.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gcd_lcm.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.integer"></a><a class="link" href="integer.html" title="Integer Type Selection">Integer Type Selection</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.easiest">Easiest-to-Manipulate
+ Types</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.sized">Sized Types</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.example">Example</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.demonstration_program">Demonstration
+ Program</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.rationale">Rationale</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.alternative">Alternative</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.credits">Credits</a></span></dt>
+</dl></div>
+<p>
+ The <a href="../../../../../boost/integer.hpp" target="_top"><boost/integer.hpp></a>
+ 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.
+ </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.synopsis"></a><a class="link" href="integer.html#boost_integer.integer.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
+<span class="special">{</span>
+ <span class="comment">// fast integers from least integers</span>
+ <span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">LeastInt</span><span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">int_fast_t</span>
+ <span class="special">{</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">type</span><span class="special">;</span>
+ <span class="special">};</span>
+
+ <span class="comment">// signed</span>
+ <span class="keyword">template</span><span class="special"><</span><span class="keyword">int</span> <span class="identifier">Bits</span><span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">int_t</span>
+ <span class="special">{</span>
+ <span class="comment">/* Member exact may or may not be defined depending upon Bits */</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">exact</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">least</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special"><</span><span class="identifier">least</span><span class="special">>::</span><span class="identifier">fast</span> <span class="identifier">fast</span><span class="special">;</span>
+ <span class="special">};</span>
+
+ <span class="comment">// unsigned</span>
+ <span class="keyword">template</span><span class="special"><</span><span class="keyword">int</span> <span class="identifier">Bits</span><span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">uint_t</span>
+ <span class="special">{</span>
+ <span class="comment">/* Member exact may or may not be defined depending upon Bits */</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">exact</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">least</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special"><</span><span class="identifier">least</span><span class="special">>::</span><span class="identifier">fast</span> <span class="identifier">fast</span><span class="special">;</span>
+ <span class="special">};</span>
+
+ <span class="comment">// signed</span>
+ <span class="keyword">template</span><span class="special"><</span><span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">MaxValue</span><span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">int_max_value_t</span>
+ <span class="special">{</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">least</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special"><</span><span class="identifier">least</span><span class="special">>::</span><span class="identifier">fast</span> <span class="identifier">fast</span><span class="special">;</span>
+ <span class="special">};</span>
+
+ <span class="keyword">template</span><span class="special"><</span><span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">MinValue</span><span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">int_min_value_t</span>
+ <span class="special">{</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">least</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special"><</span><span class="identifier">least</span><span class="special">>::</span><span class="identifier">fast</span> <span class="identifier">fast</span><span class="special">;</span>
+ <span class="special">};</span>
+
+ <span class="comment">// unsigned</span>
+ <span class="keyword">template</span><span class="special"><</span><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">Value</span><span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">uint_value_t</span>
+ <span class="special">{</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">least</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special"><</span><span class="identifier">least</span><span class="special">>::</span><span class="identifier">fast</span> <span class="identifier">fast</span><span class="special">;</span>
+ <span class="special">};</span>
+<span class="special">}</span> <span class="comment">// namespace boost</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.easiest"></a><a class="link" href="integer.html#boost_integer.integer.easiest" title="Easiest-to-Manipulate Types">Easiest-to-Manipulate
+ Types</a>
+</h3></div></div></div>
+<p>
+ The <code class="literal">int_fast_t</code> class template maps its input type to the
+ next-largest type that the processor can manipulate the easiest, or to itself
+ if the input type is already an easy-to-manipulate type. For instance, processing
+ a bunch of <code class="literal">char</code> objects may go faster if they were converted
+ to <code class="literal">int</code> objects before processing. The input type, passed
+ as the only template parameter, must be a built-in integral type, except
+ <code class="literal">bool</code>. Unsigned integral types can be used, as well as
+ signed integral types. The output type is given as the nested type <code class="literal">fast</code>.
+ </p>
+<p>
+ <span class="bold"><strong>Implementation Notes:</strong></span> 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.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.sized"></a><a class="link" href="integer.html#boost_integer.integer.sized" title="Sized Types">Sized Types</a>
+</h3></div></div></div>
+<p>
+ The <code class="literal">int_t</code>, <code class="literal">uint_t</code>, <code class="literal">int_max_value_t</code>,
+ <code class="literal">int_min_value_t</code>, and <code class="literal">uint_value_t</code> class
+ templates find the most appropiate built-in integral type for the given template
+ parameter. This type is given by the nested type <code class="literal">least</code>.
+ The easiest-to-manipulate version of that type is given by the nested type
+ <code class="literal">fast</code>. The following table describes each template's criteria.
+ </p>
+<div class="table">
+<a name="boost_integer.integer.sized.criteria_for_the_sized_type_class_templates"></a><p class="title"><b>Table 1. Criteria for the Sized Type Class Templates</b></p>
+<div class="table-contents"><table class="table" summary="Criteria for the Sized Type Class Templates">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Class Template
+ </p>
+ </th>
+<th>
+ <p>
+ Template Parameter Mapping
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::int_t<N>::least</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The smallest, built-in, signed integral type with at least <span class="emphasis"><em>N</em></span>
+ 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.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::int_t<N>::fast</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The easiest-to-manipulate, built-in, signed integral type with
+ at least <span class="emphasis"><em>N</em></span> 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.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::int_t<N>::exact</code>
+ </p>
+ </td>
+<td>
+ <p>
+ A built-in, signed integral type with exactly <span class="emphasis"><em>N</em></span>
+ bits, including the sign bit. The parameter should be a positive
+ number. Note that the member <span class="emphasis"><em>exact</em></span> is defined
+ <span class="bold"><strong>only</strong></span> if there exists a type with
+ exactly <span class="emphasis"><em>N</em></span> bits.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::uint_t<N>::least</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The smallest, built-in, unsigned integral type with at least <span class="emphasis"><em>N</em></span>
+ 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.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::uint_t<N>::fast</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The easiest-to-manipulate, built-in, unsigned integral type with
+ at least <span class="emphasis"><em>N</em></span> 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.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::uint_t<N>::exact</code>
+ </p>
+ </td>
+<td>
+ <p>
+ A built-in, unsigned integral type with exactly <span class="emphasis"><em>N</em></span>
+ 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 <span class="emphasis"><em>exact</em></span>
+ is defined <span class="bold"><strong>only</strong></span> if there exists
+ a type with exactly N bits.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::int_max_value_t<V>::last</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The smallest, built-in, signed integral type that can hold all
+ the values in the inclusive range <span class="emphasis"><em>0 - V</em></span>. The
+ parameter should be a positive number.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::int_max_value_t<V>::fast</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The easiest-to-manipulate, built-in, signed integral type that
+ can hold all the values in the inclusive range <span class="emphasis"><em>0 - V</em></span>.
+ The parameter should be a positive number.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::int_min_value_t<V>::least</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The smallest, built-in, signed integral type that can hold all
+ the values in the inclusive range <span class="emphasis"><em>V - 0</em></span>. The
+ parameter should be a negative number.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::int_min_value_t<V>::fast</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The easiest-to-manipulate, built-in, signed integral type that
+ can hold all the values in the inclusive range <span class="emphasis"><em>V - 0</em></span>.
+ The parameter should be a negative number.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::uint_value_t<V>::least</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The smallest, built-in, unsigned integral type that can hold all
+ positive values up to and including <span class="emphasis"><em>V</em></span>. The
+ parameter should be a positive number.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">boost::uint_value_t<V>::fast</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The easiest-to-manipulate, built-in, unsigned integral type that
+ can hold all positive values up to and including <span class="emphasis"><em>V</em></span>.
+ The parameter should be a positive number.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.example"></a><a class="link" href="integer.html#boost_integer.integer.example" title="Example">Example</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
+
+<span class="comment">//...</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_t</span><span class="special"><</span><span class="number">24</span><span class="special">>::</span><span class="identifier">least</span> <span class="identifier">my_var</span><span class="special">;</span> <span class="comment">// my_var has at least 24-bits</span>
+ <span class="comment">//...</span>
+ <span class="comment">// This one is guarenteed not to be truncated:</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_max_value_t</span><span class="special"><</span><span class="number">1000</span><span class="special">>::</span><span class="identifier">least</span> <span class="identifier">my1000</span> <span class="special">=</span> <span class="number">1000</span><span class="special">;</span>
+ <span class="comment">//...</span>
+ <span class="comment">// This one is guarenteed not to be truncated, and as fast</span>
+ <span class="comment">// to manipulate as possible, its size may be greater than</span>
+ <span class="comment">// that of my1000:</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_max_value_t</span><span class="special"><</span><span class="number">1000</span><span class="special">>::</span><span class="identifier">fast</span> <span class="identifier">my_fast1000</span> <span class="special">=</span> <span class="number">1000</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.demonstration_program"></a><a class="link" href="integer.html#boost_integer.integer.demonstration_program" title="Demonstration Program">Demonstration
+ Program</a>
+</h3></div></div></div>
+<p>
+ The program <a href="../../../test/integer_test.cpp" target="_top">integer_test.cpp</a>
+ is a simplistic demonstration of the results from instantiating various examples
+ of the sized type class templates.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.rationale"></a><a class="link" href="integer.html#boost_integer.integer.rationale" title="Rationale">Rationale</a>
+</h3></div></div></div>
+<p>
+ The rationale for the design of the templates in this header includes:
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ Avoid recursion because of concern about C++'s limited guaranteed recursion
+ depth (17).
+ </li>
+<li class="listitem">
+ Avoid macros on general principles.
+ </li>
+<li class="listitem">
+ Try to keep the design as simple as possible.
+ </li>
+</ul></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.alternative"></a><a class="link" href="integer.html#boost_integer.integer.alternative" title="Alternative">Alternative</a>
+</h3></div></div></div>
+<p>
+ If the number of bits required is known beforehand, it may be more appropriate
+ to use the types supplied in <a href="../../../../../boost/cstdint.hpp" target="_top"><boost/cstdint.hpp></a>.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.credits"></a><a class="link" href="integer.html#boost_integer.integer.credits" title="Credits">Credits</a>
+</h3></div></div></div>
+<p>
+ The author of most of the Boost integer type choosing templates is <a href="http://www.boost.org/people/beman_dawes.html" target="_top">Beman Dawes</a>. He
+ gives thanks to Valentin Bonnard and <a href="http://www.boost.org/people/kevlin_henney.htm" target="_top">Kevlin
+ Henney</a> for sharing their designs for similar templates. <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
+ Walker</a> designed the value-based sized templates.
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2001-2009 Beman
+ Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="traits.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gcd_lcm.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/doc/html/boost_integer/log2.html b/doc/html/boost_integer/log2.html
new file mode 100644
index 0000000..19c1a21
--- /dev/null
+++ b/doc/html/boost_integer/log2.html
@@ -0,0 +1,151 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Compile Time log2 Calculation</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="mask.html" title="Integer Masks">
+<link rel="next" href="minmax.html" title="Compile time min/max calculation">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="mask.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="minmax.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.log2"></a><a class="link" href="log2.html" title="Compile Time log2 Calculation">Compile Time log2 Calculation</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="log2.html#boost_integer.log2.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="log2.html#boost_integer.log2.usage">Usage</a></span></dt>
+<dt><span class="section"><a href="log2.html#boost_integer.log2.demonstration_program">Demonstration
+ Program</a></span></dt>
+<dt><span class="section"><a href="log2.html#boost_integer.log2.rationale">Rationale</a></span></dt>
+<dt><span class="section"><a href="log2.html#boost_integer.log2.credits">Credits</a></span></dt>
+</dl></div>
+<p>
+ The class template in <a href="../../../../../boost/integer/static_log2.hpp" target="_top"><boost/integer/static_log2.hpp></a>
+ determines the position of the highest bit in a given value. This facility
+ is useful for solving generic programming problems.
+ </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.log2.synopsis"></a><a class="link" href="log2.html#boost_integer.log2.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
+<span class="special">{</span>
+
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_log2_argument_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_log2_result_type</span><span class="special">;</span>
+
+ <span class="keyword">template</span> <span class="special"><</span><span class="identifier">static_log2_argument_type</span> <span class="identifier">arg</span><span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">static_log2</span>
+ <span class="special">{</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">static_log2_result_type</span> <span class="identifier">value</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+ <span class="special">};</span>
+
+
+ <span class="keyword">template</span> <span class="special"><</span> <span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">static_log2</span><span class="special"><</span> <span class="number">0</span> <span class="special">></span>
+ <span class="special">{</span>
+ <span class="comment">// The logarithm of zero is undefined.</span>
+ <span class="special">};</span>
+
+
+<span class="special">}</span> <span class="comment">// namespace boost</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.log2.usage"></a><a class="link" href="log2.html#boost_integer.log2.usage" title="Usage">Usage</a>
+</h3></div></div></div>
+<p>
+ The <code class="literal">boost::static_log2</code> class template takes one template
+ parameter, a value of type <code class="literal">static_log2_argument_type</code>.
+ The template only defines one member, <code class="literal">value</code>, which gives
+ the truncated, base-two logarithm of the template argument.
+ </p>
+<p>
+ Since the logarithm of zero, for any base, is undefined, there is a specialization
+ of <code class="literal">static_log2</code> 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.
+ </p>
+<p>
+ Note:
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ <code class="literal">static_log2_argument_type</code> is an <span class="emphasis"><em>unsigned
+ integer type</em></span> (C++ standard, 3.9.1p3).
+ </li>
+<li class="listitem">
+ <code class="literal">static_log2_result_type</code> is an <span class="emphasis"><em>integer type</em></span>
+ (C++ standard, 3.9.1p7).
+ </li>
+</ul></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.log2.demonstration_program"></a><a class="link" href="log2.html#boost_integer.log2.demonstration_program" title="Demonstration Program">Demonstration
+ Program</a>
+</h3></div></div></div>
+<p>
+ The program <a href="../../../test/static_log2_test.cpp" target="_top">static_log2_test.cpp</a>
+ is a simplistic demonstration of the results from instantiating various examples
+ of the binary logarithm class template.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.log2.rationale"></a><a class="link" href="log2.html#boost_integer.log2.rationale" title="Rationale">Rationale</a>
+</h3></div></div></div>
+<p>
+ 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 (<span class="emphasis"><em>i.e.</em></span> at compile-time).
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.log2.credits"></a><a class="link" href="log2.html#boost_integer.log2.credits" title="Credits">Credits</a>
+</h3></div></div></div>
+<p>
+ The original version of the Boost binary logarithm class template was written
+ by <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle Walker</a>
+ 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.
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2001-2009 Beman
+ Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="mask.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="minmax.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/doc/html/boost_integer/mask.html b/doc/html/boost_integer/mask.html
new file mode 100644
index 0000000..0d72e1e
--- /dev/null
+++ b/doc/html/boost_integer/mask.html
@@ -0,0 +1,380 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Integer Masks</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="gcd_lcm.html" title="Greatest Common Divisor and Least Common Multiple">
+<link rel="next" href="log2.html" title="Compile Time log2 Calculation">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="gcd_lcm.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="log2.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.mask"></a><a class="link" href="mask.html" title="Integer Masks">Integer Masks</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.overview">Overview</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.single_bit_mask_class_template">Single
+ Bit-Mask Class Template</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.group_bit_mask_class_template">Group
+ Bit-Mask Class Template</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.implementation_notes">Implementation
+ Notes</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.example">Example</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.demonstration_program">Demonstration
+ Program</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.rationale">Rationale</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.credits">Credits</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.overview"></a><a class="link" href="mask.html#boost_integer.mask.overview" title="Overview">Overview</a>
+</h3></div></div></div>
+<p>
+ The class templates in <a href="../../../../../boost/integer/integer_mask.hpp" target="_top"><boost/integer/integer_mask.hpp></a>
+ 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 <a class="link" href="integer.html" title="Integer Type Selection">integer
+ type selection templates</a> header.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.synopsis"></a><a class="link" href="mask.html#boost_integer.mask.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">cstddef</span><span class="special">></span> <span class="comment">// for std::size_t</span>
+
+<span class="keyword">namespace</span> <span class="identifier">boost</span>
+<span class="special">{</span>
+
+<span class="keyword">template</span> <span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Bit</span><span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">high_bit_mask_t</span>
+<span class="special">{</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">least</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">fast</span><span class="special">;</span>
+
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">least</span> <span class="identifier">high_bit</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">fast</span> <span class="identifier">high_bit_fast</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">bit_position</span> <span class="special">=</span> <span class="identifier">Bit</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">template</span> <span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Bits</span><span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">low_bits_mask_t</span>
+<span class="special">{</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">least</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span> <span class="identifier">fast</span><span class="special">;</span>
+
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">least</span> <span class="identifier">sig_bits</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">fast</span> <span class="identifier">sig_bits_fast</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">bit_count</span> <span class="special">=</span> <span class="identifier">Bits</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="comment">// Specializations for low_bits_mask_t exist for certain bit counts.</span>
+
+<span class="special">}</span> <span class="comment">// namespace boost</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.single_bit_mask_class_template"></a><a class="link" href="mask.html#boost_integer.mask.single_bit_mask_class_template" title="Single Bit-Mask Class Template">Single
+ Bit-Mask Class Template</a>
+</h3></div></div></div>
+<p>
+ The <code class="literal">boost::high_bit_mask_t</code> class template provides constants
+ for bit masks representing the bit at a certain position. The masks are equivalent
+ to the value 2<sup>Bit</sup>, where <code class="literal">Bit</code> is the template parameter.
+ The bit position must be a nonnegative number from zero to <span class="emphasis"><em>Max</em></span>,
+ 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 <code class="literal">high_bit_mask_t</code>.
+ </p>
+<div class="table">
+<a name="boost_integer.mask.single_bit_mask_class_template.members_of_the__boost__high_bit_mask_t__class_template"></a><p class="title"><b>Table 2. Members of the <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">high_bit_mask_t</span></code>
+ Class Template</b></p>
+<div class="table-contents"><table class="table" summary="Members of the boost::high_bit_mask_t
+ Class Template">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Member
+ </p>
+ </th>
+<th>
+ <p>
+ Meaning
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="literal">least</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The smallest, unsigned, built-in type that supports the given bit
+ position.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">fast</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The easiest-to-manipulate analog of <code class="literal">least</code>.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">high_bit</code>
+ </p>
+ </td>
+<td>
+ <p>
+ A <code class="literal">least</code> constant of the value 2<sup>Bit</sup>.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">high_bit_fast</code>
+ </p>
+ </td>
+<td>
+ <p>
+ A <code class="literal">fast</code> analog of <code class="literal">high_bit</code>.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">bit_position</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The value of the template parameter, in case its needed from a
+ renamed instantiation of the class template.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.group_bit_mask_class_template"></a><a class="link" href="mask.html#boost_integer.mask.group_bit_mask_class_template" title="Group Bit-Mask Class Template">Group
+ Bit-Mask Class Template</a>
+</h3></div></div></div>
+<p>
+ The <code class="literal">boost::low_bits_mask_t</code> class template provides constants
+ for bit masks equivalent to the value (2<sup>Bits</sup> - 1), where <code class="literal">Bits</code>
+ is the template parameter. The parameter <code class="literal">Bits</code> must be
+ a non-negative integer from zero to <span class="emphasis"><em>Max</em></span>, where Max is
+ the number of bits supported by the largest, unsigned, built-in integral
+ type. The following table describes the members of <code class="literal">low_bits_mask_t</code>.
+ </p>
+<div class="table">
+<a name="boost_integer.mask.group_bit_mask_class_template.members_of_the___boost__low_bits_mask_t__class_template"></a><p class="title"><b>Table 3. Members of the <code class="literal">boost::low_bits_mask_t</code> Class Template</b></p>
+<div class="table-contents"><table class="table" summary="Members of the boost::low_bits_mask_t Class Template">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Member
+ </p>
+ </th>
+<th>
+ <p>
+ Meaning
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="literal">least</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The smallest, unsigned built-in type that supports the given bit
+ count.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">fast</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The easiest-to-manipulate analog of <code class="literal">least</code>.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">sig_bits</code>
+ </p>
+ </td>
+<td>
+ <p>
+ A <code class="literal">least</code> constant of the desired bit-masking
+ value.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">sig_bits_fast</code>
+ </p>
+ </td>
+<td>
+ <p>
+ A <code class="literal">fast</code> analog of <code class="literal">sig_bits</code>.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">bit_count</code>
+ </p>
+ </td>
+<td>
+ <p>
+ The value of the template parameter, in case its needed from a
+ renamed instantiation of the class template.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.implementation_notes"></a><a class="link" href="mask.html#boost_integer.mask.implementation_notes" title="Implementation Notes">Implementation
+ Notes</a>
+</h3></div></div></div>
+<p>
+ When <code class="literal">Bits</code> is the exact size of a built-in unsigned type,
+ the implementation has to change to prevent undefined behavior. Therefore,
+ there are specializations of <code class="literal">low_bits_mask_t</code> at those
+ bit counts.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.example"></a><a class="link" href="mask.html#boost_integer.mask.example" title="Example">Example</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">integer_mask</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
+
+<span class="comment">//...</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+ <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">high_bit_mask_t</span><span class="special"><</span><span class="number">29</span><span class="special">></span> <span class="identifier">mask1_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">low_bits_mask_t</span><span class="special"><</span><span class="number">15</span><span class="special">></span> <span class="identifier">mask2_type</span><span class="special">;</span>
+
+ <span class="identifier">mask1_type</span><span class="special">::</span><span class="identifier">least</span> <span class="identifier">my_var1</span><span class="special">;</span>
+ <span class="identifier">mask2_type</span><span class="special">::</span><span class="identifier">fast</span> <span class="identifier">my_var2</span><span class="special">;</span>
+ <span class="comment">//...</span>
+
+ <span class="identifier">my_var1</span> <span class="special">|=</span> <span class="identifier">mask1_type</span><span class="special">::</span><span class="identifier">high_bit</span><span class="special">;</span>
+ <span class="identifier">my_var2</span> <span class="special">&=</span> <span class="identifier">mask2_type</span><span class="special">::</span><span class="identifier">sig_bits_fast</span><span class="special">;</span>
+
+ <span class="comment">//...</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.demonstration_program"></a><a class="link" href="mask.html#boost_integer.mask.demonstration_program" title="Demonstration Program">Demonstration
+ Program</a>
+</h3></div></div></div>
+<p>
+ The program <a href="../../../test/integer_mask_test.cpp" target="_top">integer_mask_test.cpp</a>
+ is a simplistic demonstration of the results from instantiating various examples
+ of the bit mask class templates.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.rationale"></a><a class="link" href="mask.html#boost_integer.mask.rationale" title="Rationale">Rationale</a>
+</h3></div></div></div>
+<p>
+ The class templates in this header are an extension of the <a class="link" href="integer.html" title="Integer Type Selection">integer
+ type selection class templates</a>. 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.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.credits"></a><a class="link" href="mask.html#boost_integer.mask.credits" title="Credits">Credits</a>
+</h3></div></div></div>
+<p>
+ The author of the Boost bit mask class templates is <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
+ Walker</a>.
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2001-2009 Beman
+ Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="gcd_lcm.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="log2.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/doc/html/boost_integer/minmax.html b/doc/html/boost_integer/minmax.html
new file mode 100644
index 0000000..d67425f
--- /dev/null
+++ b/doc/html/boost_integer/minmax.html
@@ -0,0 +1,160 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Compile time min/max calculation</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="log2.html" title="Compile Time log2 Calculation">
+<link rel="next" href="history.html" title="History">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="log2.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="history.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.minmax"></a><a class="link" href="minmax.html" title="Compile time min/max calculation">Compile time min/max calculation</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.usage">Usage</a></span></dt>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.example">Example</a></span></dt>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.demonstration_program">Demonstration
+ Program</a></span></dt>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.rationale">Rationale</a></span></dt>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.credits">Credits</a></span></dt>
+</dl></div>
+<p>
+ The class templates in <a href="../../../../../boost/integer/static_min_max.hpp" target="_top"><boost/integer/static_min_max.hpp></a>
+ provide a compile-time evaluation of the minimum or maximum of two integers.
+ These facilities are useful for generic programming problems.
+ </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.synopsis"></a><a class="link" href="minmax.html#boost_integer.minmax.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
+<span class="special">{</span>
+
+<span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_min_max_signed_type</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_min_max_unsigned_type</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special"><</span><span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value2</span> <span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">static_signed_min</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special"><</span><span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value2</span><span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">static_signed_max</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special"><</span><span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value2</span><span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">static_unsigned_min</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special"><</span><span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value2</span><span class="special">></span>
+ <span class="keyword">struct</span> <span class="identifier">static_unsigned_max</span><span class="special">;</span>
+
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.usage"></a><a class="link" href="minmax.html#boost_integer.minmax.usage" title="Usage">Usage</a>
+</h3></div></div></div>
+<p>
+ The four class templates provide the combinations for finding the minimum
+ or maximum of two <code class="literal">signed</code> or <code class="literal">unsigned</code>
+ (<code class="literal">long</code>) parameters, <span class="emphasis"><em>Value1</em></span> and <span class="emphasis"><em>Value2</em></span>,
+ at compile-time. Each template has a single static data member, <code class="literal">value</code>,
+ which is set to the respective minimum or maximum of the template's parameters.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.example"></a><a class="link" href="minmax.html#boost_integer.minmax.example" title="Example">Example</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">static_min_max</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
+
+<span class="keyword">template</span> <span class="special"><</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">AddendSize1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">AddendSize2</span> <span class="special">></span>
+<span class="keyword">class</span> <span class="identifier">adder</span>
+<span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">const</span> <span class="identifier">addend1_size</span> <span class="special">=</span> <span class="identifier">AddendSize1</span><span class="special">;</span>
+ <span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">const</span> <span class="identifier">addend2_size</span> <span class="special">=</span> <span class="identifier">AddendSize2</span><span class="special">;</span>
+ <span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">const</span> <span class="identifier">sum_size</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">static_unsigned_max</span><span class="special"><</span><span class="identifier">AddendSize1</span><span class="special">,</span> <span class="identifier">AddendSize2</span><span class="special">>::</span><span class="identifier">value</span> <span class="special">+</span> <span class="number">1</span><span class="special">;</span>
+
+ <span class="keyword">typedef</span> <span class="keyword">int</span> <span class="identifier">addend1_type</span><span class="special">[</span> <span class="identifier">addend1_size</span> <span class="special">];</span>
+ <span class="keyword">typedef</span> <span class="keyword">int</span> <span class="identifier">addend2_type</span><span class="special">[</span> <span class="identifier">addend2_size</span> <span class="special">];</span>
+ <span class="keyword">typedef</span> <span class="keyword">int</span> <span class="identifier">sum_type</span><span class="special">[</span> <span class="identifier">sum_size</span> <span class="special">];</span>
+
+ <span class="keyword">void</span> <span class="keyword">operator</span> <span class="special">()(</span> <span class="identifier">addend1_type</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a1</span><span class="special">,</span> <span class="identifier">addend2_type</span> <span class="keyword">const</span> <span class="special">&</span><span class="identifier">a2</span><span class="special">,</span> <span class="identifier">sum_type</span> <span class="special">&</span><span class="identifier">s</span> <span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="comment">//...</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+ <span class="keyword">int</span> <span class="keyword">const</span> <span class="identifier">a1</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</span><span class="special">,</span> <span class="number">4</span><span class="special">,</span> <span class="number">3</span> <span class="special">};</span> <span class="comment">// 340</span>
+ <span class="keyword">int</span> <span class="keyword">const</span> <span class="identifier">a2</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="number">9</span><span class="special">,</span> <span class="number">8</span> <span class="special">};</span> <span class="comment">// 89</span>
+ <span class="keyword">int</span> <span class="identifier">s</span><span class="special">[</span> <span class="number">4</span> <span class="special">];</span>
+ <span class="identifier">adder</span><span class="special"><</span><span class="number">3</span><span class="special">,</span><span class="number">2</span><span class="special">></span> <span class="identifier">obj</span><span class="special">;</span>
+
+ <span class="identifier">obj</span><span class="special">(</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">,</span> <span class="identifier">s</span> <span class="special">);</span> <span class="comment">// 's' should be 429 or { 9, 2, 4, 0 }</span>
+ <span class="comment">//...</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.demonstration_program"></a><a class="link" href="minmax.html#boost_integer.minmax.demonstration_program" title="Demonstration Program">Demonstration
+ Program</a>
+</h3></div></div></div>
+<p>
+ The program <a href="../../../test/static_min_max_test.cpp" target="_top">static_min_max_test.cpp</a>
+ is a simplistic demonstration of various comparisons using the compile-time
+ extrema class templates.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.rationale"></a><a class="link" href="minmax.html#boost_integer.minmax.rationale" title="Rationale">Rationale</a>
+</h3></div></div></div>
+<p>
+ Sometimes the minimum or maximum of several values needs to be found for
+ later compile-time processing, <span class="emphasis"><em>e.g.</em></span> for a bound for
+ another class template.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.credits"></a><a class="link" href="minmax.html#boost_integer.minmax.credits" title="Credits">Credits</a>
+</h3></div></div></div>
+<p>
+ The author of the Boost compile-time extrema class templates is <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
+ Walker</a>.
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2001-2009 Beman
+ Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="log2.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="history.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/doc/html/boost_integer/traits.html b/doc/html/boost_integer/traits.html
new file mode 100644
index 0000000..76987ad
--- /dev/null
+++ b/doc/html/boost_integer/traits.html
@@ -0,0 +1,215 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Integer Traits</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="../index.html" title="Boost.Integer">
+<link rel="next" href="integer.html" title="Integer Type Selection">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integer.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.traits"></a><a class="link" href="traits.html" title="Integer Traits">Integer Traits</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="traits.html#boost_integer.traits.motivation">Motivation</a></span></dt>
+<dt><span class="section"><a href="traits.html#boost_integer.traits.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="traits.html#boost_integer.traits.description">Description</a></span></dt>
+<dt><span class="section"><a href="traits.html#boost_integer.traits.test_program">Test Program</a></span></dt>
+<dt><span class="section"><a href="traits.html#boost_integer.traits.acknowledgements">Acknowledgements</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.traits.motivation"></a><a class="link" href="traits.html#boost_integer.traits.motivation" title="Motivation">Motivation</a>
+</h3></div></div></div>
+<p>
+ The C++ Standard Library <limits> header supplies a class template
+ <code class="computeroutput"><span class="identifier">numeric_limits</span><span class="special"><></span></code>
+ with specializations for each fundamental type.
+ </p>
+<p>
+ For integer types, the interesting members of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special"><></span></code> are:
+ </p>
+<pre class="programlisting"><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_specialized</span><span class="special">;</span> <span class="comment">// Will be true for integer types.</span>
+<span class="keyword">static</span> <span class="identifier">T</span> <span class="identifier">min</span><span class="special">()</span> <span class="keyword">throw</span><span class="special">();</span> <span class="comment">// Smallest representable value.</span>
+<span class="keyword">static</span> <span class="identifier">T</span> <span class="identifier">max</span><span class="special">()</span> <span class="keyword">throw</span><span class="special">();</span> <span class="comment">// Largest representable value.</span>
+<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">digits</span><span class="special">;</span> <span class="comment">// For integers, the number of value bits.</span>
+<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">digits10</span><span class="special">;</span> <span class="comment">// The number of base 10 digits that can be represented.</span>
+<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_signed</span><span class="special">;</span> <span class="comment">// True if the type is signed.</span>
+<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_integer</span><span class="special">;</span> <span class="comment">// Will be true for all integer types.</span>
+</pre>
+<p>
+ 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.
+ </p>
+<p>
+ The template class <code class="literal">integer_traits</code> addresses this problem.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.traits.synopsis"></a><a class="link" href="traits.html#boost_integer.traits.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+ <span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span>
+ <span class="keyword">class</span> <span class="identifier">integer_traits</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span>
+ <span class="special">{</span>
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_integral</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
+ <span class="comment">//</span>
+ <span class="comment">// These members are defined only if T is a built-in</span>
+ <span class="comment">// integal type:</span>
+ <span class="comment">//</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="identifier">const_min</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="identifier">const_max</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+ <span class="special">};</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.traits.description"></a><a class="link" href="traits.html#boost_integer.traits.description" title="Description">Description</a>
+</h3></div></div></div>
+<p>
+ Template class <code class="literal">integer_traits</code> is derived from <code class="literal">std::numeric_limits</code>.
+ The primary specialization adds the single <code class="literal">bool</code> member
+ <code class="literal">is_integral</code> with the compile-time constant value <code class="literal">false</code>.
+ However, for all integral types <code class="literal">T</code> (std::3.9.1/7 [basic.fundamental]),
+ there are specializations provided with the following compile-time constants
+ defined:
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ member
+ </p>
+ </th>
+<th>
+ <p>
+ type
+ </p>
+ </th>
+<th>
+ <p>
+ value
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="literal">is_integral</code>
+ </p>
+ </td>
+<td>
+ <p>
+ bool
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">true</code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">const_min</code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">T</code>
+ </p>
+ </td>
+<td>
+ <p>
+ equivalent to <code class="literal">std::numeric_limits<T>::min()</code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="literal">const_max</code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">T</code>
+ </p>
+ </td>
+<td>
+ <p>
+ equivalent to <code class="literal">std::numeric_limits<T>::max()</code>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+ Note: The <span class="emphasis"><em>is_integral</em></span> flag is provided, because a user-defined
+ integer class should specialize <code class="literal">std::numeric_limits<>::is_integer
+ = true</code>, while compile-time constants <code class="literal">const_min</code>
+ and <code class="literal">const_max</code> are not provided for that user-defined class,
+ unless boost::integer_traits is also specialized.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.traits.test_program"></a><a class="link" href="traits.html#boost_integer.traits.test_program" title="Test Program">Test Program</a>
+</h3></div></div></div>
+<p>
+ The program <code class="literal"><a href="../../../test/integer_traits_test.cpp" target="_top">integer_traits_test.cpp</a></code>
+ exercises the <code class="literal">integer_traits</code> class.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.traits.acknowledgements"></a><a class="link" href="traits.html#boost_integer.traits.acknowledgements" title="Acknowledgements">Acknowledgements</a>
+</h3></div></div></div>
+<p>
+ Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer
+ traits idea on the boost mailing list in August 1999.
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2001-2009 Beman
+ Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integer.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/doc/html/index.html b/doc/html/index.html
new file mode 100644
index 0000000..040ad3e
--- /dev/null
+++ b/doc/html/index.html
@@ -0,0 +1,251 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Boost.Integer</title>
+<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="index.html" title="Boost.Integer">
+<link rel="next" href="boost_integer/traits.html" title="Integer Traits">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
+<td align="center"><a href="../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="boost_integer/traits.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
+<div class="article">
+<div class="titlepage">
+<div>
+<div><h2 class="title">
+<a name="boost_integer"></a>Boost.Integer</h2></div>
+<div><div class="authorgroup">
+<div class="author"><h3 class="author">
+<span class="firstname">Beman</span> <span class="surname">Dawes</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">Daryle</span> <span class="surname">Walker</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">Gennaro</span> <span class="surname">Prota</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">John</span> <span class="surname">Maddock</span>
+</h3></div>
+</div></div>
+<div><p class="copyright">Copyright © 2001-2009 Beman
+ Dawes, Daryle Walker, Gennaro Prota, John Maddock</p></div>
+<div><div class="legalnotice">
+<a name="boost_integer.legal"></a><p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+ </p>
+</div></div>
+</div>
+<hr>
+</div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<dl>
+<dt><span class="section"><a href="index.html#boost_integer.overview">Overview</a></span></dt>
+<dt><span class="section"><a href="boost_integer/traits.html">Integer Traits</a></span></dt>
+<dt><span class="section"><a href="boost_integer/integer.html">Integer Type Selection</a></span></dt>
+<dt><span class="section"><a href="boost_integer/gcd_lcm.html">Greatest Common Divisor and Least
+ Common Multiple</a></span></dt>
+<dt><span class="section"><a href="boost_integer/mask.html">Integer Masks</a></span></dt>
+<dt><span class="section"><a href="boost_integer/log2.html">Compile Time log2 Calculation</a></span></dt>
+<dt><span class="section"><a href="boost_integer/minmax.html">Compile time min/max calculation</a></span></dt>
+<dt><span class="section"><a href="boost_integer/history.html">History</a></span></dt>
+<dt><span class="section"><a href="boost_integer/cstdint.html">Removed from library: Standard Integer
+ Types</a></span></dt>
+</dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.overview"></a><a class="link" href="index.html#boost_integer.overview" title="Overview">Overview</a>
+</h2></div></div></div>
+<p>
+ Boost.Integer provides integer type support, particularly helpful in generic
+ programming. 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 <code class="computeroutput"><span class="identifier">min</span></code>
+ and <code class="computeroutput"><span class="identifier">max</span></code>. 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.
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Component
+ </p>
+ </th>
+<th>
+ <p>
+ Header
+ </p>
+ </th>
+<th>
+ <p>
+ Purpose
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Forward Declarations.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal"><a href="../../../../boost/integer_fwd.hpp" target="_top"><boost/integer_fwd.hpp></a></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward declarations of classes and class templates - for use when
+ just the name of a class is needed.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <a class="link" href="boost_integer/traits.html" title="Integer Traits">Integer Traits</a>.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal"><a href="../../../../boost/integer_traits.hpp" target="_top"><boost/integer_traits.hpp></a></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Class template <code class="literal">boost::integer_traits</code>, derives
+ from <code class="literal">std::numeric_limits</code> and adds <code class="literal">const_min</code>
+ and <code class="literal">const_max</code> members.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <a class="link" href="boost_integer/integer.html" title="Integer Type Selection">Integer Type Selection</a>.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal"><a href="../../../../boost/integer.hpp" target="_top"><boost/integer.hpp></a></code>
+ </p>
+ </td>
+<td>
+ <p>
+ 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.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <a class="link" href="boost_integer/gcd_lcm.html" title="Greatest Common Divisor and Least Common Multiple">Greatest Common Divisor and
+ Least Common Multiple</a>.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal"><a href="../../../../boost/integer/common_factor_rt.hpp" target="_top"><boost/integer/common_factor_rt.hpp></a></code>
+ and <code class="literal"><a href="../../../../boost/integer/common_factor_ct.hpp" target="_top"><boost/integer/common_factor_ct.hpp></a></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Functions <code class="computeroutput"><span class="identifier">gcd</span></code> and
+ <code class="computeroutput"><span class="identifier">lcm</span></code> plus function
+ objects and compile time versions.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <a class="link" href="boost_integer/mask.html" title="Integer Masks">Integer Masks</a>.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal"><a href="../../../../boost/integer/integer_mask.hpp" target="_top"><boost/integer/integer_mask.hpp></a></code>
+ </p>
+ </td>
+<td>
+ <p>
+ 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.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <a class="link" href="boost_integer/log2.html" title="Compile Time log2 Calculation">Compile time log2 Calculation</a>.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal"><a href="../../../../boost/integer/static_log2.hpp" target="_top"><boost/integer/static_log2.hpp></a></code>
+ </p>
+ </td>
+<td>
+ <p>
+ 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.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <a class="link" href="boost_integer/minmax.html" title="Compile time min/max calculation">Compile time min/max calculation</a>.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal"><a href="../../../../boost/integer/static_min_max.hpp" target="_top"><boost/integer/static_min_max.hpp></a></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Templates for finding the extrema of two numbers: Use to find a bound
+ based on a minimum or maximum value. Useful for generic programming.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"><p><small>Last revised: April 24, 2017 at 17:49:59 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="boost_integer/traits.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
+</body>
+</html>
diff --git a/doc/integer.qbk b/doc/integer.qbk
new file mode 100644
index 0000000..75042f2
--- /dev/null
+++ b/doc/integer.qbk
@@ -0,0 +1,712 @@
+[article Boost.Integer
+ [quickbook 1.6]
+ [compatibility-mode 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 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.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.gcd_lcm Greatest Common Divisor and Least Common Multiple].]
+ [[^[@../../../../boost/integer/common_factor_rt.hpp <boost/integer/common_factor_rt.hpp>]] and [^[@../../../../boost/integer/common_factor_ct.hpp <boost/integer/common_factor_ct.hpp>]]]
+ [Functions `gcd` and `lcm` plus function objects and compile time versions.]
+ ]
+ [
+ [[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: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]
+
+[include gcd/math-gcd.qbk]
+
+
+[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.56.0]
+
+* Moved `<boost/cstdint.hpp>` into [@boost:/libs/config/index.html
+ Boost.Config].
+
+[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]
+
+[section:cstdint Removed from library: Standard Integer Types]
+
+The [@boost:/libs/config/doc/html/boost_config/cstdint.html Boost.Config] module provides
+the typedefs useful for writing portable code that requires certain
+integer widths.
+
+[endsect]